@cubis/foundry 0.3.83 → 0.3.84

package/mcp/dist/index.js

@@ -450,8 +450,8 @@ function estimateTokensFromCharCount(charCount, charsPerToken) {
   const ratio = normalizeCharsPerToken(charsPerToken);
   return Math.ceil(safeChars / ratio);
 }
-function estimateTokensFromText(text, charsPerToken) {
-  return estimateTokensFromCharCount(text.length, charsPerToken);
+function estimateTokensFromText(text2, charsPerToken) {
+  return estimateTokensFromCharCount(text2.length, charsPerToken);
 }
 function estimateTokensFromBytes(byteCount, charsPerToken) {
   return estimateTokensFromCharCount(byteCount, charsPerToken);
@@ -675,15 +675,80 @@ async function readSkillFrontmatter(skillPath) {
   return parseSkillFrontmatter(content);
 }
 
+// src/runtime/buildFreshness.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import path5 from "path";
+function newestMtimeInTree(dirPath) {
+  let newest = 0;
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const resolved = path5.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      newest = Math.max(newest, newestMtimeInTree(resolved));
+      continue;
+    }
+    if (entry.isFile()) {
+      newest = Math.max(newest, statSync(resolved).mtimeMs);
+    }
+  }
+  return newest;
+}
+function getBuildFreshnessStatus(packageRoot) {
+  const sourceRoot = path5.join(packageRoot, "src");
+  const distEntry = path5.join(packageRoot, "dist", "index.js");
+  if (!existsSync(sourceRoot)) {
+    return {
+      sourceRoot,
+      distEntry,
+      checked: false,
+      fresh: true,
+      detail: "Source tree is not present in this package layout."
+    };
+  }
+  if (!existsSync(distEntry)) {
+    return {
+      sourceRoot,
+      distEntry,
+      checked: true,
+      fresh: false,
+      detail: "Built MCP entry is missing."
+    };
+  }
+  const newestSourceMtime = newestMtimeInTree(sourceRoot);
+  const distMtime = statSync(distEntry).mtimeMs;
+  if (newestSourceMtime > distMtime) {
+    return {
+      sourceRoot,
+      distEntry,
+      checked: true,
+      fresh: false,
+      detail: "Built MCP output is older than mcp/src. Rebuild with `npm run build:mcp` or `npm run build:cli`."
+    };
+  }
+  return {
+    sourceRoot,
+    distEntry,
+    checked: true,
+    fresh: true,
+    detail: "Built MCP output is fresh."
+  };
+}
+function assertBuildFreshness(packageRoot) {
+  const status = getBuildFreshnessStatus(packageRoot);
+  if (status.checked && !status.fresh) {
+    throw new Error(status.detail);
+  }
+}
+
 // src/vault/generatedManifest.ts
 import { readFile as readFile3 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 function normalizeStringArray(values) {
   if (!Array.isArray(values)) return [];
   return [...new Set(values.map((value) => String(value || "").trim()).filter(Boolean))];
 }
 async function loadGeneratedSkillManifest(mcpPackageRoot) {
-  const filePath = path5.resolve(mcpPackageRoot, "generated", "mcp-manifest.json");
+  const filePath = path6.resolve(mcpPackageRoot, "generated", "mcp-manifest.json");
   try {
     const raw = await readFile3(filePath, "utf8");
     const parsed = JSON.parse(raw);
@@ -726,10 +791,10 @@ function mergeGeneratedSkillMetadata(scannedSkills, generatedManifest) {
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z16 } from "zod";
+import { z as z21 } from "zod";
 
 // src/tools/routeResolve.ts
-import path6 from "path";
+import path7 from "path";
 import process2 from "process";
 import { promises as fs } from "fs";
 import { z as z2 } from "zod";
@@ -737,7 +802,7 @@ var routeResolveName = "route_resolve";
 var routeResolveDescription = "Resolve an explicit workflow command, explicit custom agent, compatibility alias, or free-text intent into one workflow/agent route before skill loading.";
 var routeResolveSchema = z2.object({
   intent: z2.string().min(1).describe(
-    "Explicit workflow command (/mobile), explicit agent (@mobile-developer), compatibility alias ($workflow-mobile / $agent-mobile-developer), or free-text user intent"
+    "Explicit workflow command (/implement), explicit agent (@reviewer), compatibility alias ($workflow-implement / $agent-reviewer), or free-text user intent"
   )
 });
 var ROUTE_STOP_WORDS = /* @__PURE__ */ new Set([
@@ -835,6 +900,62 @@ var LEGACY_AGENT_ALIASES = {
   "product-owner": "product-manager",
   "explorer-agent": "code-archaeologist"
 };
+var STITCH_REQUIRED_SIGNALS = ["stitch"];
+var DESIGN_SYSTEM_SIGNALS = [
+  "design system",
+  "design-system",
+  "design tokens",
+  "theme system",
+  "token system"
+];
+var DESIGN_AUDIT_SIGNALS = [
+  "design audit",
+  "ui audit",
+  "ux audit",
+  "visual audit",
+  "design review"
+];
+var DESIGN_REFRESH_SIGNALS = [
+  "design refresh",
+  "refresh design",
+  "refresh tokens",
+  "design drift"
+];
+var DESIGN_SCREEN_SIGNALS = [
+  "design screen",
+  "screen design",
+  "ui design",
+  "ux design",
+  "landing page",
+  "redesign",
+  "mobile screen"
+];
+var STITCH_UI_SUPPORTING_SKILLS = [
+  "frontend-design-core",
+  "frontend-design-style-selector",
+  "frontend-design-system",
+  "frontend-design-screen-brief",
+  "stitch-prompt-enhancement",
+  "stitch-design-orchestrator",
+  "stitch-design-system",
+  "stitch-implementation-handoff"
+];
+var MOBILE_DESIGN_SUPPORTING_SKILLS = [
+  "frontend-design-mobile-patterns",
+  "frontend-design-implementation-handoff"
+];
+var MOBILE_QA_SIGNALS = [
+  "mobile qa",
+  "android qa",
+  "flutter qa",
+  "emulator qa"
+];
+var WEB_QA_SIGNALS = [
+  "web qa",
+  "browser qa",
+  "playwright qa",
+  "website qa"
+];
 function normalize(value) {
   return value.toLowerCase().replace(/[^a-z0-9@/$+-]+/g, " ").trim();
 }
@@ -865,6 +986,14 @@ function isSkillCreatorIntent(intent) {
   if (!hasObjectSignal) return false;
   return includesAnyPhrase(normalizedIntent, SKILL_CREATOR_ACTION_SIGNALS);
 }
+function isStitchUiIntent(intent) {
+  const normalizedIntent = normalize(intent);
+  return includesAnyPhrase(normalizedIntent, STITCH_REQUIRED_SIGNALS);
+}
+function isDesignIntent(intent) {
+  const normalizedIntent = normalize(intent);
+  return includesAnyPhrase(normalizedIntent, DESIGN_SYSTEM_SIGNALS) || includesAnyPhrase(normalizedIntent, DESIGN_AUDIT_SIGNALS) || includesAnyPhrase(normalizedIntent, DESIGN_REFRESH_SIGNALS) || includesAnyPhrase(normalizedIntent, DESIGN_SCREEN_SIGNALS);
+}
 function chooseSkillCreatorRoute(intent, manifest) {
   if (!isSkillCreatorIntent(intent)) return null;
   const normalizedIntent = normalize(intent);
@@ -965,8 +1094,10 @@ function resolveByIntent(intent, manifest) {
   if (best.score < 80 && best.tokenMatches < 2) return null;
   return best;
 }
-function buildResolvedPayload(input, route, matchedBy, detectedLanguageSkill) {
-  const primarySkillHint = isSkillCreatorIntent(input) ? "skill-creator" : route.primarySkills[0] || null;
+function buildResolvedPayload(input, route, matchedBy, detectedLanguageSkill, overrides = {}) {
+  const primarySkills = overrides.primarySkills || route.primarySkills;
+  const supportingSkills = overrides.supportingSkills || route.supportingSkills;
+  const primarySkillHint = overrides.primarySkillHint !== void 0 ? overrides.primarySkillHint : isSkillCreatorIntent(input) ? "skill-creator" : primarySkills[0] || null;
   return {
     input,
     resolved: true,
@@ -975,15 +1106,50 @@ function buildResolvedPayload(input, route, matchedBy, detectedLanguageSkill) {
     command: route.command,
     agent: route.primaryAgent,
     primarySkillHint,
-    primarySkills: route.primarySkills,
-    supportingSkills: route.supportingSkills,
+    primarySkills,
+    supportingSkills,
     detectedLanguageSkill,
     fallbackSkillSearchRecommended: false,
     matchedBy,
-    explanation: matchedBy === "explicit-workflow-command" ? `Matched explicit workflow command ${route.command}.` : matchedBy === "explicit-agent" ? `Matched explicit agent @${route.id}.` : matchedBy === "legacy-workflow-alias" ? `Matched legacy workflow alias and routed to canonical workflow '${route.id}'.` : matchedBy === "legacy-agent-alias" ? `Matched legacy agent alias and routed to canonical agent @${route.id}.` : matchedBy === "compatibility-alias" ? `Matched compatibility alias ${route.artifacts.codex?.compatibilityAlias}.` : matchedBy === "skill-creator-intent" ? `Matched workflow '${route.id}' and selected skill-creator as the primary skill hint for skill package work.` : `Matched ${route.kind} '${route.id}' from installed route metadata.`,
+    explanation: overrides.explanation ?? (matchedBy === "explicit-workflow-command" ? `Matched explicit workflow command ${route.command}.` : matchedBy === "explicit-agent" ? `Matched explicit agent @${route.id}.` : matchedBy === "legacy-workflow-alias" ? `Matched legacy workflow alias and routed to canonical workflow '${route.id}'.` : matchedBy === "legacy-agent-alias" ? `Matched legacy agent alias and routed to canonical agent @${route.id}.` : matchedBy === "compatibility-alias" ? `Matched compatibility alias ${route.artifacts.codex?.compatibilityAlias}.` : matchedBy === "skill-creator-intent" ? `Matched workflow '${route.id}' and selected skill-creator as the primary skill hint for skill package work.` : `Matched ${route.kind} '${route.id}' from installed route metadata.`),
     artifacts: route.artifacts
   };
 }
+function chooseStitchUiRoute(manifest) {
+  return manifest.routes.find(
+    (entry) => entry.kind === "workflow" && (entry.id === "design-screen" || entry.command === "/design-screen")
+  ) || null;
+}
+function chooseQaRoute(intent, manifest) {
+  const normalizedIntent = normalize(intent);
+  const wantsMobileQa = includesAnyPhrase(normalizedIntent, MOBILE_QA_SIGNALS) || /\b(android|flutter|emulator|adb)\b/.test(normalizedIntent) && /\b(test|qa|verify|validation)\b/.test(normalizedIntent);
+  if (wantsMobileQa) {
+    return manifest.routes.find(
+      (entry) => entry.kind === "workflow" && entry.id === "mobile-qa"
+    ) || null;
+  }
+  const wantsWebQa = includesAnyPhrase(normalizedIntent, WEB_QA_SIGNALS) || /\b(playwright|browser|web|website|page|pages)\b/.test(normalizedIntent) && /\b(test|qa|verify|validation)\b/.test(normalizedIntent);
+  if (wantsWebQa) {
+    return manifest.routes.find(
+      (entry) => entry.kind === "workflow" && entry.id === "web-qa"
+    ) || null;
+  }
+  return null;
+}
+function chooseDesignRoute(intent, manifest) {
+  const normalizedIntent = normalize(intent);
+  let preferredWorkflowId = "design-screen";
+  if (includesAnyPhrase(normalizedIntent, DESIGN_SYSTEM_SIGNALS)) {
+    preferredWorkflowId = "design-system";
+  } else if (includesAnyPhrase(normalizedIntent, DESIGN_AUDIT_SIGNALS)) {
+    preferredWorkflowId = "design-audit";
+  } else if (includesAnyPhrase(normalizedIntent, DESIGN_REFRESH_SIGNALS)) {
+    preferredWorkflowId = "design-refresh";
+  }
+  return manifest.routes.find(
+    (entry) => entry.kind === "workflow" && entry.id === preferredWorkflowId
+  ) || null;
+}
 async function fileExists(target) {
   try {
     await fs.stat(target);
@@ -1004,7 +1170,7 @@ async function detectLanguageSkillHint() {
         }
         continue;
       }
-      if (has(fileName) || await fileExists(path6.join(cwd, fileName))) {
+      if (has(fileName) || await fileExists(path7.join(cwd, fileName))) {
         if (entry.skillId === "javascript-pro") {
           const tsSignals = ["tsconfig.json", "tsconfig.base.json", "deno.json"];
           if (tsSignals.some((signal) => has(signal))) {
@@ -1046,6 +1212,96 @@ async function handleRouteResolve(args, routeManifest) {
       structuredContent: payload2
     };
   }
+  const qaRoute = chooseQaRoute(intent, routeManifest);
+  if (qaRoute) {
+    const payload2 = buildResolvedPayload(
+      intent,
+      qaRoute,
+      "qa-runtime-intent",
+      detectedLanguageSkill,
+      {
+        primarySkillHint: qaRoute.id === "web-qa" ? "playwright-web-qa" : "flutter-mobile-qa",
+        primarySkills: qaRoute.id === "web-qa" ? ["playwright-web-qa", "playwright-interactive"] : ["flutter-mobile-qa"],
+        supportingSkills: qaRoute.supportingSkills,
+        explanation: qaRoute.id === "web-qa" ? "Matched web QA intent and routed to /web-qa so Playwright MCP execution, evidence capture, and QA reporting stay on the dedicated web runtime path." : "Matched mobile QA intent and routed to /mobile-qa so Android MCP execution, emulator evidence capture, and fallback rules stay on the dedicated mobile runtime path."
+      }
+    );
+    return {
+      content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }],
+      structuredContent: payload2
+    };
+  }
+  if (isStitchUiIntent(intent)) {
+    const stitchRoute = chooseStitchUiRoute(routeManifest);
+    if (stitchRoute) {
+      const needsMobilePatterns = /\b(mobile|flutter|android|ios)\b/i.test(intent);
+      const payload2 = buildResolvedPayload(
+        intent,
+        stitchRoute,
+        "stitch-ui-intent",
+        detectedLanguageSkill,
+        {
+          primarySkillHint: "frontend-design",
+          primarySkills: [
+            "frontend-design",
+            ...needsMobilePatterns ? MOBILE_DESIGN_SUPPORTING_SKILLS : [],
+            ...STITCH_UI_SUPPORTING_SKILLS
+          ],
+          supportingSkills: stitchRoute.supportingSkills,
+          explanation: "Matched Stitch UI intent and routed to /design-screen so the design engine resolves canonical design state, builds the screen brief, and only then runs the Stitch sequence."
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }],
+        structuredContent: payload2
+      };
+    }
+  }
+  if (isDesignIntent(intent)) {
+    const designRoute = chooseDesignRoute(intent, routeManifest);
+    if (designRoute) {
+      const needsMobilePatterns = /\b(mobile|flutter|android|ios)\b/i.test(intent);
+      const primarySkills = [
+        "frontend-design",
+        "frontend-design-core"
+      ];
+      if (designRoute.id === "design-system") {
+        primarySkills.push("frontend-design-style-selector", "frontend-design-system");
+      } else if (designRoute.id === "design-audit") {
+        primarySkills.push("frontend-design-style-selector");
+      } else if (designRoute.id === "design-refresh") {
+        primarySkills.push(
+          "frontend-design-style-selector",
+          "frontend-design-system",
+          "frontend-design-screen-brief"
+        );
+      } else {
+        primarySkills.push(
+          "frontend-design-style-selector",
+          "frontend-design-screen-brief"
+        );
+      }
+      if (needsMobilePatterns) {
+        primarySkills.push(...MOBILE_DESIGN_SUPPORTING_SKILLS);
+      }
+      const payload2 = buildResolvedPayload(
+        intent,
+        designRoute,
+        "design-intent",
+        detectedLanguageSkill,
+        {
+          primarySkillHint: "frontend-design",
+          primarySkills,
+          supportingSkills: designRoute.supportingSkills,
+          explanation: "Matched design intent and routed through the design engine so canonical design state, overlays, and screen briefs resolve before implementation or generation."
+        }
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }],
+        structuredContent: payload2
+      };
+    }
+  }
   const inferred = resolveByIntent(intent, routeManifest);
   if (inferred) {
     const payload2 = buildResolvedPayload(
@@ -1096,18 +1352,18 @@ function handleSkillListCategories(manifest, charsPerToken) {
     skillCount: categoryCounts[cat] ?? 0
   }));
   const payload = { categories, totalSkills: manifest.skills.length };
-  const text = JSON.stringify(payload, null, 2);
+  const text2 = JSON.stringify(payload, null, 2);
   const metrics = buildSkillToolMetrics({
     charsPerToken,
     fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-    responseEstimatedTokens: estimateTokensFromText(text, charsPerToken),
-    responseCharacterCount: text.length
+    responseEstimatedTokens: estimateTokensFromText(text2, charsPerToken),
+    responseCharacterCount: text2.length
   });
   return {
     content: [
       {
         type: "text",
-        text
+        text: text2
       }
     ],
     structuredContent: {
@@ -1150,10 +1406,10 @@ var skillBrowseCategorySchema = z4.object({
   category: z4.string().describe("The category name to browse (from skill_list_categories)")
 });
 function summarizeDescription(description, maxLength) {
-  const text = String(description || "").trim();
-  if (!text) return "(no description)";
-  if (text.length <= maxLength) return text;
-  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+  const text2 = String(description || "").trim();
+  if (!text2) return "(no description)";
+  if (text2.length <= maxLength) return text2;
+  return `${text2.slice(0, Math.max(0, maxLength - 3))}...`;
 }
 async function handleSkillBrowseCategory(args, manifest, summaryMaxLength, charsPerToken) {
   const { category } = args;
@@ -1166,7 +1422,7 @@ async function handleSkillBrowseCategory(args, manifest, summaryMaxLength, chars
     description: summarizeDescription(s.description, summaryMaxLength)
   }));
   const payload = { category, skills, count: skills.length };
-  const text = JSON.stringify(payload, null, 2);
+  const text2 = JSON.stringify(payload, null, 2);
   const selectedSkillsEstimatedTokens = matching.reduce(
     (sum, skill) => sum + estimateTokensFromBytes(skill.fileBytes, charsPerToken),
     0
@@ -1174,15 +1430,15 @@ async function handleSkillBrowseCategory(args, manifest, summaryMaxLength, chars
   const metrics = buildSkillToolMetrics({
     charsPerToken,
     fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-    responseEstimatedTokens: estimateTokensFromText(text, charsPerToken),
+    responseEstimatedTokens: estimateTokensFromText(text2, charsPerToken),
     selectedSkillsEstimatedTokens,
-    responseCharacterCount: text.length
+    responseCharacterCount: text2.length
   });
   return {
     content: [
       {
         type: "text",
-        text
+        text: text2
       }
     ],
     structuredContent: {
@@ -1244,10 +1500,10 @@ function normalizeSignalList(values) {
   return normalizeSearchText((values || []).join(" "));
 }
 function summarizeDescription2(description, maxLength) {
-  const text = String(description || "").trim();
-  if (!text) return "(no description)";
-  if (text.length <= maxLength) return text;
-  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+  const text2 = String(description || "").trim();
+  if (!text2) return "(no description)";
+  if (text2.length <= maxLength) return text2;
+  return `${text2.slice(0, Math.max(0, maxLength - 3))}...`;
 }
 async function handleSkillSearch(args, manifest, summaryMaxLength, charsPerToken) {
   const { query } = args;
@@ -1298,7 +1554,7 @@ async function handleSkillSearch(args, manifest, summaryMaxLength, charsPerToken
     description: summarizeDescription2(s.description, summaryMaxLength)
   }));
   const payload = { query, results, count: results.length };
-  const text = JSON.stringify(payload, null, 2);
+  const text2 = JSON.stringify(payload, null, 2);
   const selectedSkillsEstimatedTokens = matches.reduce(
     (sum, skill) => sum + estimateTokensFromBytes(skill.fileBytes, charsPerToken),
     0
@@ -1306,15 +1562,15 @@ async function handleSkillSearch(args, manifest, summaryMaxLength, charsPerToken
   const metrics = buildSkillToolMetrics({
     charsPerToken,
     fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-    responseEstimatedTokens: estimateTokensFromText(text, charsPerToken),
+    responseEstimatedTokens: estimateTokensFromText(text2, charsPerToken),
     selectedSkillsEstimatedTokens,
-    responseCharacterCount: text.length
+    responseCharacterCount: text2.length
   });
   return {
     content: [
       {
         type: "text",
-        text
+        text: text2
       }
     ],
     structuredContent: payload,
@@ -1354,15 +1610,15 @@ async function handleSkillValidate(args, manifest, charsPerToken) {
       replacementId: null,
       availableReferences: []
     };
-    const text2 = JSON.stringify(payload2, null, 2);
+    const text3 = JSON.stringify(payload2, null, 2);
     const metrics2 = buildSkillToolMetrics({
       charsPerToken,
       fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-      responseEstimatedTokens: estimateTokensFromText(text2, charsPerToken),
-      responseCharacterCount: text2.length
+      responseEstimatedTokens: estimateTokensFromText(text3, charsPerToken),
+      responseCharacterCount: text3.length
     });
     return {
-      content: [{ type: "text", text: text2 }],
+      content: [{ type: "text", text: text3 }],
       structuredContent: payload2,
       _meta: { metrics: metrics2 }
     };
@@ -1385,15 +1641,15 @@ async function handleSkillValidate(args, manifest, charsPerToken) {
     replacementId,
     availableReferences
   };
-  const text = JSON.stringify(payload, null, 2);
+  const text2 = JSON.stringify(payload, null, 2);
   const metrics = buildSkillToolMetrics({
     charsPerToken,
     fullCatalogEstimatedTokens: manifest.fullCatalogEstimatedTokens,
-    responseEstimatedTokens: estimateTokensFromText(text, charsPerToken),
-    responseCharacterCount: text.length
+    responseEstimatedTokens: estimateTokensFromText(text2, charsPerToken),
+    responseCharacterCount: text2.length
   });
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: "text", text: text2 }],
     structuredContent: payload,
     _meta: { metrics }
   };
@@ -1486,7 +1742,7 @@ function assertConcreteSkillId2(id) {
   }
 }
 async function handleSkillGetReference(args, manifest, charsPerToken) {
-  const { id, path: path11 } = args;
+  const { id, path: path18 } = args;
   assertConcreteSkillId2(id);
   const skill = manifest.skills.find((entry) => entry.id === id);
   if (!skill) {
@@ -1494,7 +1750,7 @@ async function handleSkillGetReference(args, manifest, charsPerToken) {
   }
   let reference;
   try {
-    reference = await readSkillReferenceFile(skill.path, path11);
+    reference = await readSkillReferenceFile(skill.path, path18);
   } catch (error) {
     invalidInput(error instanceof Error ? error.message : String(error));
   }
@@ -1601,12 +1857,12 @@ function handleSkillBudgetReport(args, manifest, charsPerToken) {
       estimated: true
     }
   };
-  const text = JSON.stringify(payload, null, 2);
+  const text2 = JSON.stringify(payload, null, 2);
   return {
     content: [
       {
         type: "text",
-        text
+        text: text2
       }
     ],
     structuredContent: payload,
@@ -1618,18 +1874,18 @@ function handleSkillBudgetReport(args, manifest, charsPerToken) {
 import { z as z10 } from "zod";
 
 // src/cbxConfig/paths.ts
-import path7 from "path";
+import path8 from "path";
 import os from "os";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 function resolveHomeDir() {
   return process.env.HOME || process.env.USERPROFILE || os.homedir();
 }
 function globalConfigPath() {
-  return path7.join(resolveHomeDir(), ".cbx", "cbx_config.json");
+  return path8.join(resolveHomeDir(), ".cbx", "cbx_config.json");
 }
 function projectConfigPath(workspaceRoot) {
   const root = workspaceRoot ?? process.cwd();
-  return path7.join(root, "cbx_config.json");
+  return path8.join(root, "cbx_config.json");
 }
 function resolveConfigPath(scope, workspaceRoot) {
   if (scope === "global") {
@@ -1639,17 +1895,17 @@ function resolveConfigPath(scope, workspaceRoot) {
     return { path: projectConfigPath(workspaceRoot), scope: "project" };
   }
   const projectPath = projectConfigPath(workspaceRoot);
-  if (existsSync(projectPath)) {
+  if (existsSync2(projectPath)) {
     return { path: projectPath, scope: "project" };
   }
   return { path: globalConfigPath(), scope: "global" };
 }
 
 // src/cbxConfig/reader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
 import { parse as parseJsonc } from "jsonc-parser";
 function readConfigFile(filePath) {
-  if (!existsSync2(filePath)) return null;
+  if (!existsSync3(filePath)) return null;
   try {
     const raw = readFileSync2(filePath, "utf8");
     return parseJsonc(raw);
@@ -1703,15 +1959,15 @@ import {
   writeFileSync,
   renameSync,
   mkdirSync,
-  existsSync as existsSync3
+  existsSync as existsSync4
 } from "fs";
-import path8 from "path";
+import path9 from "path";
 import { parse as parseJsonc2 } from "jsonc-parser";
 function writeConfigField(fieldPath, value, scope, workspaceRoot) {
   const resolved = resolveConfigPath(scope, workspaceRoot);
   const configPath = resolved.path;
   let config = {};
-  if (existsSync3(configPath)) {
+  if (existsSync4(configPath)) {
     try {
       const raw = readFileSync3(configPath, "utf8");
       config = parseJsonc2(raw);
@@ -1731,8 +1987,8 @@ function writeConfigField(fieldPath, value, scope, workspaceRoot) {
     current = current[key];
   }
   current[parts[parts.length - 1]] = value;
-  const dir = path8.dirname(configPath);
-  if (!existsSync3(dir)) {
+  const dir = path9.dirname(configPath);
+  if (!existsSync4(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   const tmpPath = `${configPath}.tmp.${Date.now()}`;
@@ -1745,6 +2001,10 @@ function writeConfigField(fieldPath, value, scope, workspaceRoot) {
 // src/cbxConfig/serviceConfig.ts
 var DEFAULT_POSTMAN_URL = "https://mcp.postman.com/minimal";
 var DEFAULT_STITCH_URL = "https://stitch.googleapis.com/mcp";
+var DEFAULT_PLAYWRIGHT_PORT = 8931;
+var DEFAULT_PLAYWRIGHT_URL = `http://localhost:${DEFAULT_PLAYWRIGHT_PORT}/mcp`;
+var DEFAULT_ANDROID_COMMAND = "npx";
+var DEFAULT_ANDROID_PACKAGE = "android-mcp-server@1.3.0";
 var DEFAULT_PROFILE_NAME = "default";
 var DEFAULT_POSTMAN_ENV_VAR = "POSTMAN_API_KEY";
 var DEFAULT_STITCH_ENV_VAR = "STITCH_API_KEY";
@@ -1855,6 +2115,34 @@ function parseStitchState(config) {
     useSystemGcloud: Boolean(section.useSystemGcloud)
   };
 }
+function parsePlaywrightState(config) {
+  const section = asRecord(config.playwright) ?? {};
+  const portRaw = typeof section.port === "number" ? section.port : DEFAULT_PLAYWRIGHT_PORT;
+  const port = Number.isFinite(portRaw) && portRaw > 0 && portRaw < 65536 ? portRaw : DEFAULT_PLAYWRIGHT_PORT;
+  const envPort = process.env.PLAYWRIGHT_MCP_PORT ? Number(process.env.PLAYWRIGHT_MCP_PORT) : void 0;
+  const effectivePort = envPort && Number.isFinite(envPort) && envPort > 0 && envPort < 65536 ? envPort : port;
+  const mcpUrl = normalizeOptionalString(section.mcpUrl) ?? `http://localhost:${effectivePort}/mcp`;
+  return { mcpUrl, port: effectivePort };
+}
+function parseAndroidState(config) {
+  const section = asRecord(config.android) ?? {};
+  const enabled = Boolean(section.enabled ?? config.android);
+  const command = normalizeOptionalString(section.command) ?? DEFAULT_ANDROID_COMMAND;
+  const packageSpec = normalizeOptionalString(section.package) ?? DEFAULT_ANDROID_PACKAGE;
+  const args = Array.isArray(section.args) ? section.args.map((value) => normalizeOptionalString(value)).filter((value) => Boolean(value)) : ["-y", packageSpec];
+  const cwd = normalizeOptionalString(section.cwd);
+  const envRecord = asRecord(section.env) ?? {};
+  const env = Object.fromEntries(
+    Object.entries(envRecord).map(([key, value]) => [key, normalizeOptionalString(value)]).filter((entry) => Boolean(entry[1]))
+  );
+  return {
+    enabled,
+    command,
+    args: args.length > 0 ? args : ["-y", packageSpec],
+    cwd,
+    env
+  };
+}
 
 // src/tools/postmanModes.ts
 var POSTMAN_MODES = {
@@ -2159,171 +2447,35 @@ function handleStitchGetStatus(args) {
   };
 }
 
-// src/tools/registry.ts
-function withDefaultScope(args, defaultScope) {
-  const safeArgs = args && typeof args === "object" ? args : {};
-  return {
-    ...safeArgs,
-    scope: typeof safeArgs.scope === "string" ? safeArgs.scope : defaultScope
-  };
-}
-var TOOL_REGISTRY = [
-  // ── Route tools ───────────────────────────────────────────
-  {
-    name: routeResolveName,
-    description: routeResolveDescription,
-    schema: routeResolveSchema,
-    category: "route",
-    createHandler: (ctx) => async (args) => handleRouteResolve(
-      args,
-      ctx.routeManifest
-    )
-  },
-  // ── Skill vault tools ─────────────────────────────────────
-  {
-    name: skillListCategoriesName,
-    description: skillListCategoriesDescription,
-    schema: skillListCategoriesSchema,
-    category: "skill",
-    createHandler: (ctx) => async () => handleSkillListCategories(ctx.manifest, ctx.charsPerToken)
-  },
-  {
-    name: skillBrowseCategoryName,
-    description: skillBrowseCategoryDescription,
-    schema: skillBrowseCategorySchema,
-    category: "skill",
-    createHandler: (ctx) => async (args) => handleSkillBrowseCategory(
-      args,
-      ctx.manifest,
-      ctx.summaryMaxLength,
-      ctx.charsPerToken
-    )
-  },
-  {
-    name: skillSearchName,
-    description: skillSearchDescription,
-    schema: skillSearchSchema,
-    category: "skill",
-    createHandler: (ctx) => async (args) => handleSkillSearch(
-      args,
-      ctx.manifest,
-      ctx.summaryMaxLength,
-      ctx.charsPerToken
-    )
-  },
-  {
-    name: skillValidateName,
-    description: skillValidateDescription,
-    schema: skillValidateSchema,
-    category: "skill",
-    createHandler: (ctx) => async (args) => handleSkillValidate(
-      args,
-      ctx.manifest,
-      ctx.charsPerToken
-    )
-  },
-  {
-    name: skillGetName,
-    description: skillGetDescription,
-    schema: skillGetSchema,
-    category: "skill",
-    createHandler: (ctx) => async (args) => handleSkillGet(
-      args,
-      ctx.manifest,
-      ctx.charsPerToken
-    )
-  },
-  {
-    name: skillGetReferenceName,
-    description: skillGetReferenceDescription,
-    schema: skillGetReferenceSchema,
-    category: "skill",
-    createHandler: (ctx) => async (args) => handleSkillGetReference(
-      args,
-      ctx.manifest,
-      ctx.charsPerToken
-    )
-  },
-  {
-    name: skillBudgetReportName,
-    description: skillBudgetReportDescription,
-    schema: skillBudgetReportSchema,
-    category: "skill",
-    createHandler: (ctx) => async (args) => handleSkillBudgetReport(
-      args,
-      ctx.manifest,
-      ctx.charsPerToken
-    )
-  },
-  // ── Postman tools ─────────────────────────────────────────
-  {
-    name: postmanGetModeName,
-    description: postmanGetModeDescription,
-    schema: postmanGetModeSchema,
-    category: "postman",
-    createHandler: (ctx) => async (args) => handlePostmanGetMode(
-      withDefaultScope(args, ctx.defaultConfigScope)
-    )
-  },
-  {
-    name: postmanSetModeName,
-    description: postmanSetModeDescription,
-    schema: postmanSetModeSchema,
-    category: "postman",
-    createHandler: (ctx) => async (args) => handlePostmanSetMode(
-      withDefaultScope(args, ctx.defaultConfigScope)
-    )
-  },
-  {
-    name: postmanGetStatusName,
-    description: postmanGetStatusDescription,
-    schema: postmanGetStatusSchema,
-    category: "postman",
-    createHandler: (ctx) => async (args) => handlePostmanGetStatus(
-      withDefaultScope(args, ctx.defaultConfigScope)
-    )
-  },
-  // ── Stitch tools ──────────────────────────────────────────
-  {
-    name: stitchGetModeName,
-    description: stitchGetModeDescription,
-    schema: stitchGetModeSchema,
-    category: "stitch",
-    createHandler: (ctx) => async (args) => handleStitchGetMode(
-      withDefaultScope(args, ctx.defaultConfigScope)
-    )
-  },
-  {
-    name: stitchSetProfileName,
-    description: stitchSetProfileDescription,
-    schema: stitchSetProfileSchema,
-    category: "stitch",
-    createHandler: (ctx) => async (args) => handleStitchSetProfile(
-      withDefaultScope(args, ctx.defaultConfigScope)
-    )
-  },
-  {
-    name: stitchGetStatusName,
-    description: stitchGetStatusDescription,
-    schema: stitchGetStatusSchema,
-    category: "stitch",
-    createHandler: (ctx) => async (args) => handleStitchGetStatus(
-      withDefaultScope(args, ctx.defaultConfigScope)
-    )
-  }
-];
+// src/tools/stitchExecute.ts
+import path13 from "path";
+import { z as z16 } from "zod";
 
 // src/upstream/passthrough.ts
 import { mkdir, readFile as readFile4, writeFile } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var STITCH_ENV_FALLBACKS = ["STITCH_API_KEY_DEFAULT", "STITCH_API_KEY"];
+var STITCH_LONG_RUNNING_TIMEOUT_MS = 8 * 60 * 1e3;
+var STITCH_DISCOVERY_TIMEOUT_MS = 30 * 1e3;
+var STITCH_DEFAULT_COMPLEX_MODEL = "GEMINI_3_1_PRO";
+var STITCH_MUTATION_TOOLS = /* @__PURE__ */ new Set([
+  "generate_screen_from_text",
+  "edit_screens",
+  "generate_variants"
+]);
+var STITCH_TIMEOUT_RECOVERY_TOOLS = /* @__PURE__ */ new Set([
+  "generate_screen_from_text",
+  "generate_variants"
+]);
 function resolveCatalogDir(configPath) {
-  const configDir = path9.dirname(configPath);
-  if (path9.basename(configDir) === ".cbx") {
-    return path9.join(configDir, "mcp", "catalog");
+  const configDir = path10.dirname(configPath);
+  if (path10.basename(configDir) === ".cbx") {
+    return path10.join(configDir, "mcp", "catalog");
   }
-  return path9.join(configDir, ".cbx", "mcp", "catalog");
+  return path10.join(configDir, ".cbx", "mcp", "catalog");
 }
 function buildPassthroughAliasName(service, toolName) {
   const normalizedTool = String(toolName || "").trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_").toLowerCase();
@@ -2351,7 +2503,7 @@ async function loadCachedCatalogTools({
 }) {
   if (!configPath) return [];
   const catalogDir = resolveCatalogDir(configPath);
-  const catalogPath = path9.join(catalogDir, `${service}.json`);
+  const catalogPath = path10.join(catalogDir, `${service}.json`);
   try {
     const raw = await readFile4(catalogPath, "utf8");
     const parsed = JSON.parse(raw);
@@ -2365,14 +2517,42 @@ async function loadCachedCatalogTools({
   }
 }
 function getServiceAuth(config, service) {
-  if (service === "postman") {
-    const state2 = parsePostmanState(config);
-    const activeProfile2 = state2.activeProfile;
-    const envVar2 = activeProfile2?.apiKeyEnvVar ?? "POSTMAN_API_KEY";
-    const token2 = process.env[envVar2]?.trim();
-    if (!token2) {
-      return {
-        mcpUrl: state2.mcpUrl,
+  if (service === "android") {
+    const state2 = parseAndroidState(config);
+    return {
+      transport: "stdio",
+      mcpUrl: null,
+      activeProfileName: null,
+      envVar: null,
+      headers: {},
+      command: state2.command,
+      args: state2.args,
+      env: state2.env,
+      cwd: state2.cwd,
+      configured: Boolean(state2.enabled && state2.command),
+      error: state2.enabled && state2.command ? void 0 : "Android MCP is not enabled in cbx_config.json"
+    };
+  }
+  if (service === "playwright") {
+    const state2 = parsePlaywrightState(config);
+    return {
+      transport: "http",
+      mcpUrl: state2.mcpUrl,
+      activeProfileName: null,
+      envVar: null,
+      headers: {},
+      configured: Boolean(state2.mcpUrl)
+    };
+  }
+  if (service === "postman") {
+    const state2 = parsePostmanState(config);
+    const activeProfile2 = state2.activeProfile;
+    const envVar2 = activeProfile2?.apiKeyEnvVar ?? "POSTMAN_API_KEY";
+    const token2 = process.env[envVar2]?.trim();
+    if (!token2) {
+      return {
+        transport: "http",
+        mcpUrl: state2.mcpUrl,
         activeProfileName: state2.activeProfileName,
         envVar: envVar2,
         headers: {},
@@ -2381,6 +2561,7 @@ function getServiceAuth(config, service) {
       };
     }
     return {
+      transport: "http",
       mcpUrl: state2.mcpUrl,
       activeProfileName: state2.activeProfileName,
       envVar: envVar2,
@@ -2391,211 +2572,2034 @@ function getServiceAuth(config, service) {
   const state = parseStitchState(config);
   const activeProfile = state.activeProfile;
   const envVar = activeProfile?.apiKeyEnvVar ?? "STITCH_API_KEY";
-  const token = process.env[envVar]?.trim();
+  const tokenInfo = resolveStitchToken(envVar);
+  const token = tokenInfo?.token;
   if (!token && !state.useSystemGcloud) {
     return {
+      transport: "http",
       mcpUrl: state.mcpUrl,
       activeProfileName: state.activeProfileName,
-      envVar,
+      envVar: tokenInfo?.envVar || envVar,
       headers: {},
       configured: false,
       error: `Missing Stitch key env var: ${envVar}`
     };
   }
   return {
-    mcpUrl: state.mcpUrl,
-    activeProfileName: state.activeProfileName,
-    envVar,
-    headers: token ? { "X-Goog-Api-Key": token } : {},
-    configured: Boolean(state.mcpUrl)
+    transport: "http",
+    mcpUrl: state.mcpUrl,
+    activeProfileName: state.activeProfileName,
+    envVar: tokenInfo?.envVar || envVar,
+    headers: token ? { "X-Goog-Api-Key": token } : {},
+    configured: Boolean(state.mcpUrl)
+  };
+}
+function resolveStitchToken(preferredEnvVar, env = process.env) {
+  const candidates = [preferredEnvVar, ...STITCH_ENV_FALLBACKS].filter(Boolean);
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    const token = env[candidate]?.trim();
+    if (token) {
+      return { envVar: candidate, token };
+    }
+  }
+  return null;
+}
+async function withUpstreamClient({
+  transport,
+  url,
+  headers,
+  command,
+  args,
+  env,
+  cwd,
+  fn
+}) {
+  const client = new Client(
+    {
+      name: "cubis-foundry-mcp-passthrough",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {}
+    }
+  );
+  const clientTransport = transport === "stdio" ? new StdioClientTransport({
+    command: command || "npx",
+    args: args || [],
+    env: env || {},
+    cwd: cwd || process.cwd(),
+    stderr: "pipe"
+  }) : new StreamableHTTPClientTransport(new URL(url || ""), {
+    requestInit: { headers }
+  });
+  await client.connect(clientTransport);
+  try {
+    return await fn(client);
+  } finally {
+    await client.close();
+  }
+}
+function isCallToolResult(result) {
+  return Array.isArray(
+    result.content
+  );
+}
+function normalizeUpstreamToolResult(result) {
+  if (isCallToolResult(result)) {
+    return result;
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            toolResult: result.toolResult
+          },
+          null,
+          2
+        )
+      }
+    ],
+    _meta: result._meta
+  };
+}
+function isStitchLongRunningTool(name) {
+  return STITCH_MUTATION_TOOLS.has(String(name || "").trim());
+}
+function getUpstreamRequestOptions(service, name) {
+  if (service !== "stitch" || !isStitchLongRunningTool(name)) {
+    return void 0;
+  }
+  return {
+    timeout: STITCH_LONG_RUNNING_TIMEOUT_MS,
+    maxTotalTimeout: STITCH_LONG_RUNNING_TIMEOUT_MS,
+    resetTimeoutOnProgress: true
+  };
+}
+function applyStitchDefaultArguments(name, argumentsValue) {
+  if (name !== "generate_screen_from_text" && name !== "edit_screens") {
+    return argumentsValue;
+  }
+  const next = { ...argumentsValue };
+  if (typeof next.modelId !== "string" || !next.modelId.trim()) {
+    next.modelId = STITCH_DEFAULT_COMPLEX_MODEL;
+  }
+  return next;
+}
+async function listStitchScreens(client, projectId) {
+  const response = normalizeUpstreamToolResult(
+    await client.callTool(
+      {
+        name: "list_screens",
+        arguments: { projectId }
+      },
+      void 0,
+      {
+        timeout: STITCH_DISCOVERY_TIMEOUT_MS
+      }
+    )
+  );
+  const text2 = response.content.find((item) => item.type === "text")?.text;
+  if (!text2) return [];
+  try {
+    const parsed = JSON.parse(text2);
+    return Array.isArray(parsed.screens) ? parsed.screens : [];
+  } catch {
+    return [];
+  }
+}
+async function listStitchProjects(client) {
+  const response = normalizeUpstreamToolResult(
+    await client.callTool(
+      {
+        name: "list_projects",
+        arguments: {}
+      },
+      void 0,
+      {
+        timeout: STITCH_DISCOVERY_TIMEOUT_MS
+      }
+    )
+  );
+  const text2 = response.content.find((item) => item.type === "text")?.text;
+  if (!text2) return [];
+  try {
+    const parsed = JSON.parse(text2);
+    return Array.isArray(parsed.projects) ? parsed.projects : [];
+  } catch {
+    return [];
+  }
+}
+function findMatchingStitchProject(projects, title) {
+  const normalizedTitle = title.trim().toLowerCase();
+  if (!normalizedTitle) return null;
+  return projects.find(
+    (project) => typeof project.title === "string" && project.title.trim().toLowerCase() === normalizedTitle
+  ) || null;
+}
+function isTimeoutError(error) {
+  const text2 = String(error || "");
+  return text2.includes("Request timed out") || text2.includes("RequestTimeout");
+}
+function buildStitchTimeoutRecoveryResult({
+  toolName,
+  projectId,
+  screens
+}) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            service: "stitch",
+            tool: `stitch.${toolName}`,
+            projectId,
+            recoveredAfterTimeout: true,
+            message: "The Stitch request timed out locally, but new screens were detected in the project. Treat these as recovered results and prefer edit_screens for follow-up changes.",
+            outputComponents: screens.map((screen) => ({
+              text: `Recovered screen ${screen.title || screen.name || "unknown"} after timeout.`,
+              design: {
+                screens: [screen]
+              }
+            }))
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+async function persistCatalog(catalog) {
+  if (!catalog.configPath) return;
+  const catalogDir = resolveCatalogDir(catalog.configPath);
+  const catalogPath = path10.join(catalogDir, `${catalog.service}.json`);
+  const payload = {
+    schemaVersion: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    generatedBy: "cubis-foundry-mcp startup discovery",
+    service: catalog.service,
+    scope: catalog.scope,
+    mcpUrl: catalog.mcpUrl,
+    activeProfileName: catalog.activeProfileName,
+    envVar: catalog.envVar,
+    toolCount: catalog.toolCount,
+    tools: catalog.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? null,
+      inputSchema: tool.inputSchema ?? null,
+      outputSchema: tool.outputSchema ?? null
+    })),
+    discoveryError: catalog.discoveryError ?? null
+  };
+  await mkdir(catalogDir, { recursive: true });
+  await writeFile(catalogPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+async function discoverUpstreamCatalogs(scope = "auto") {
+  const effective = readEffectiveConfig(scope);
+  if (!effective) {
+    const missing = {
+      service: "postman",
+      configured: false,
+      mcpUrl: null,
+      activeProfileName: null,
+      envVar: null,
+      scope: null,
+      configPath: null,
+      toolCount: 0,
+      tools: [],
+      discoveryError: "cbx_config.json not found"
+    };
+    const missingStitch = { ...missing, service: "stitch" };
+    const missingPlaywright = {
+      ...missing,
+      service: "playwright"
+    };
+    const missingAndroid = {
+      ...missing,
+      service: "android"
+    };
+    return {
+      postman: missing,
+      stitch: missingStitch,
+      playwright: missingPlaywright,
+      android: missingAndroid
+    };
+  }
+  const baseInfo = {
+    scope: effective.scope,
+    configPath: effective.path
+  };
+  const discoverOne = async (service) => {
+    const auth = getServiceAuth(effective.config, service);
+    const catalog = {
+      service,
+      configured: auth.configured,
+      mcpUrl: auth.mcpUrl,
+      activeProfileName: auth.activeProfileName,
+      envVar: auth.envVar,
+      scope: baseInfo.scope,
+      configPath: baseInfo.configPath,
+      toolCount: 0,
+      tools: [],
+      discoveryError: auth.error
+    };
+    if (!auth.configured || !auth.mcpUrl || auth.error) {
+      const missingConnection = auth.transport === "http" ? !auth.mcpUrl : !(auth.command && auth.command.trim());
+      if (!missingConnection && !auth.error) {
+      } else {
+        const cachedTools = await loadCachedCatalogTools({
+          service,
+          scope: baseInfo.scope,
+          configPath: baseInfo.configPath
+        });
+        if (cachedTools.length > 0) {
+          catalog.tools = cachedTools;
+          catalog.toolCount = cachedTools.length;
+          catalog.discoveryError = auth.error ? `${auth.error} (using cached tool catalog)` : "Upstream not configured; using cached tool catalog";
+        }
+        await persistCatalog(catalog);
+        return catalog;
+      }
+    }
+    try {
+      const listed = await withUpstreamClient({
+        transport: auth.transport,
+        url: auth.mcpUrl,
+        headers: auth.headers,
+        command: auth.command,
+        args: auth.args,
+        env: auth.env,
+        cwd: auth.cwd,
+        fn: async (client) => client.listTools()
+      });
+      const rawTools = Array.isArray(listed.tools) ? listed.tools : [];
+      catalog.tools = rawTools.map((tool) => buildUpstreamToolInfo(service, tool || {})).filter((tool) => Boolean(tool));
+      catalog.toolCount = catalog.tools.length;
+    } catch (error) {
+      catalog.discoveryError = `Tool discovery failed: ${String(error)}`;
+      const cachedTools = await loadCachedCatalogTools({
+        service,
+        scope: baseInfo.scope,
+        configPath: baseInfo.configPath
+      });
+      if (cachedTools.length > 0) {
+        catalog.tools = cachedTools;
+        catalog.toolCount = cachedTools.length;
+        catalog.discoveryError = `${catalog.discoveryError} (using cached tool catalog)`;
+      }
+    }
+    await persistCatalog(catalog);
+    return catalog;
+  };
+  return {
+    postman: await discoverOne("postman"),
+    stitch: await discoverOne("stitch"),
+    playwright: await discoverOne("playwright"),
+    android: await discoverOne("android")
+  };
+}
+async function callUpstreamTool({
+  service,
+  name,
+  argumentsValue,
+  scope = "auto"
+}) {
+  const effective = readEffectiveConfig(scope);
+  if (!effective) {
+    throw new Error("cbx_config.json not found");
+  }
+  const auth = getServiceAuth(effective.config, service);
+  const missingConnection = auth.transport === "http" ? !auth.mcpUrl : !(auth.command && auth.command.trim());
+  if (!auth.configured || missingConnection) {
+    throw new Error(auth.error || `${service} is not configured`);
+  }
+  if (auth.error) {
+    throw new Error(auth.error);
+  }
+  return withUpstreamClient({
+    transport: auth.transport,
+    url: auth.mcpUrl,
+    headers: auth.headers,
+    command: auth.command,
+    args: auth.args,
+    env: auth.env,
+    cwd: auth.cwd,
+    fn: async (client) => {
+      const effectiveArguments = service === "stitch" ? applyStitchDefaultArguments(name, argumentsValue) : argumentsValue;
+      const requestOptions = getUpstreamRequestOptions(service, name);
+      const projectId = service === "stitch" && typeof effectiveArguments.projectId === "string" ? effectiveArguments.projectId.trim() : "";
+      const shouldRecoverAfterTimeout = service === "stitch" && STITCH_TIMEOUT_RECOVERY_TOOLS.has(name) && projectId.length > 0;
+      if (service === "stitch" && name === "create_project" && typeof effectiveArguments.title === "string") {
+        const existingProject = findMatchingStitchProject(
+          await listStitchProjects(client),
+          effectiveArguments.title
+        );
+        if (existingProject) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    ...existingProject,
+                    reusedExistingProject: true,
+                    message: "Reused an existing Stitch project with the same title instead of creating a duplicate."
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+      }
+      const beforeScreens = shouldRecoverAfterTimeout && projectId ? await listStitchScreens(client, projectId) : [];
+      try {
+        return normalizeUpstreamToolResult(
+          await client.callTool(
+            {
+              name,
+              arguments: effectiveArguments
+            },
+            void 0,
+            requestOptions
+          )
+        );
+      } catch (error) {
+        if (shouldRecoverAfterTimeout && projectId && isTimeoutError(error)) {
+          const knownNames = new Set(
+            beforeScreens.map((screen) => screen.name).filter(Boolean)
+          );
+          const afterScreens = await listStitchScreens(client, projectId);
+          const recoveredScreens = afterScreens.filter(
+            (screen) => screen.name && !knownNames.has(screen.name)
+          );
+          if (recoveredScreens.length > 0) {
+            return buildStitchTimeoutRecoveryResult({
+              toolName: name,
+              projectId,
+              screens: recoveredScreens
+            });
+          }
+        }
+        throw error;
+      }
+    }
+  });
+}
+
+// src/runtime/executionTrace.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path11 from "path";
+function createExecutionTrace(flow, inputs) {
+  return {
+    flow,
+    inputs,
+    gates: [],
+    selectedSkills: [],
+    selectedReferences: [],
+    toolCalls: [],
+    retries: [],
+    artifacts: [],
+    result: null,
+    errors: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    finishedAt: null
+  };
+}
+function finishExecutionTrace(trace, result) {
+  trace.result = result;
+  trace.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return trace;
+}
+async function persistExecutionTrace(trace, options) {
+  const workspaceRoot = options?.workspaceRoot ?? process.cwd();
+  const now = options?.timestamp ?? /* @__PURE__ */ new Date();
+  const stamp = now.toISOString().replace(/[:.]/g, "-");
+  const filename = `${stamp}-${trace.flow}.json`;
+  const traceDir = path11.join(workspaceRoot, "artifacts", "foundry-traces");
+  const tracePath = path11.join(traceDir, filename);
+  await mkdir2(traceDir, { recursive: true });
+  await writeFile2(tracePath, `${JSON.stringify(trace, null, 2)}
+`, "utf8");
+  return tracePath;
+}
+
+// src/runtime/designState.ts
+import { existsSync as existsSync5 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import path12 from "path";
+async function collectMarkdownFiles(dirPath) {
+  if (!existsSync5(dirPath)) {
+    return [];
+  }
+  const entries = await readdir2(dirPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const resolved = path12.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectMarkdownFiles(resolved));
+      continue;
+    }
+    if (entry.isFile() && /\.(md|mdx|txt)$/i.test(entry.name)) {
+      files.push(resolved);
+    }
+  }
+  return files;
+}
+async function inspectDesignState(workspaceRoot = process.cwd()) {
+  const requiredPaths = [
+    path12.join(workspaceRoot, "docs", "foundation", "DESIGN.md")
+  ];
+  const overlayRoots = [
+    path12.join(workspaceRoot, "docs", "foundation", "design", "pages"),
+    path12.join(workspaceRoot, "docs", "foundation", "design", "flows"),
+    path12.join(workspaceRoot, "docs", "foundation", "design", "mobile")
+  ];
+  const requiredExisting = requiredPaths.filter((filePath) => existsSync5(filePath));
+  const overlayFiles = (await Promise.all(overlayRoots.map((root) => collectMarkdownFiles(root)))).flat();
+  const referencePaths = [...requiredExisting, ...overlayFiles];
+  const ready = requiredExisting.length > 0 || overlayFiles.length > 0;
+  return {
+    ready,
+    requiredPaths,
+    referencePaths,
+    detail: ready ? `Found ${referencePaths.length} design reference file(s).` : "Missing canonical design state. Add docs/foundation/DESIGN.md or design overlay files before Stitch generation."
+  };
+}
+
+// src/tools/stitchExecute.ts
+var stitchExecuteModeSchema = z16.enum(["auto", "generate", "edit", "variants"]);
+var stitchExecuteName = "stitch_execute";
+var stitchExecuteDescription = "Run a guarded Stitch execution flow with design gating, project reuse, screen reuse, timeout recovery, and persisted execution traces.";
+var stitchExecuteSchema = z16.object({
+  mode: stitchExecuteModeSchema.default("auto"),
+  prompt: z16.string().min(1).describe("Design-ready Stitch prompt or edit brief."),
+  projectTitle: z16.string().optional(),
+  projectId: z16.string().optional(),
+  screenTitle: z16.string().optional(),
+  scope: z16.enum(["auto", "global", "project"]).optional().describe("Config scope to read. Default: auto.")
+});
+function textResult(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function parseCallToolTextResult(result) {
+  const text2 = result.content.find((item) => item.type === "text")?.text?.trim() || null;
+  if (!text2) {
+    return { raw: null, text: null };
+  }
+  try {
+    return { raw: JSON.parse(text2), text: text2 };
+  } catch {
+    return { raw: null, text: text2 };
+  }
+}
+function parseProjects(result) {
+  const parsed = parseCallToolTextResult(result);
+  const projects = parsed.raw?.projects;
+  return Array.isArray(projects) ? projects : [];
+}
+function parseScreens(result) {
+  const parsed = parseCallToolTextResult(result);
+  const screens = parsed.raw?.screens;
+  return Array.isArray(screens) ? screens : [];
+}
+function findMatchingScreen(screens, title) {
+  const normalized = title.trim().toLowerCase();
+  if (!normalized) return null;
+  return screens.find((screen) => {
+    const candidates = [screen.title, screen.name].filter((value) => typeof value === "string").map((value) => value.trim().toLowerCase());
+    return candidates.includes(normalized);
+  }) || null;
+}
+async function ensureProjectId({
+  projectId,
+  projectTitle,
+  scope,
+  trace
+}) {
+  if (projectId?.trim()) {
+    return { projectId: projectId.trim(), reusedProject: true };
+  }
+  const title = projectTitle?.trim();
+  if (!title) {
+    throw new Error("stitch_execute requires projectId or projectTitle.");
+  }
+  trace.toolCalls.push({
+    name: "stitch.list_projects",
+    phase: "preflight",
+    outcome: "planned",
+    arguments: {}
+  });
+  const projectsResult = await callUpstreamTool({
+    service: "stitch",
+    name: "list_projects",
+    argumentsValue: {},
+    scope
+  });
+  trace.toolCalls[trace.toolCalls.length - 1].outcome = "success";
+  const existingProject = findMatchingStitchProject(parseProjects(projectsResult), title);
+  if (existingProject?.name) {
+    return { projectId: existingProject.name, reusedProject: true };
+  }
+  trace.toolCalls.push({
+    name: "stitch.create_project",
+    phase: "execute",
+    outcome: "planned",
+    arguments: { title }
+  });
+  const createdResult = await callUpstreamTool({
+    service: "stitch",
+    name: "create_project",
+    argumentsValue: { title },
+    scope
+  });
+  const parsed = parseCallToolTextResult(createdResult);
+  trace.toolCalls[trace.toolCalls.length - 1].outcome = "success";
+  const createdProjectId = typeof parsed.raw?.name === "string" && parsed.raw.name.trim() ? parsed.raw.name.trim() : "";
+  if (!createdProjectId) {
+    throw new Error("Stitch create_project did not return a project identifier.");
+  }
+  return { projectId: createdProjectId, reusedProject: false };
+}
+async function listProjectScreens({
+  projectId,
+  scope,
+  trace
+}) {
+  trace.toolCalls.push({
+    name: "stitch.list_screens",
+    phase: "preflight",
+    outcome: "planned",
+    arguments: { projectId }
+  });
+  const screensResult = await callUpstreamTool({
+    service: "stitch",
+    name: "list_screens",
+    argumentsValue: { projectId },
+    scope
+  });
+  trace.toolCalls[trace.toolCalls.length - 1].outcome = "success";
+  return parseScreens(screensResult);
+}
+function createStitchExecuteHandler(ctx) {
+  return async function handleStitchExecute(args) {
+    const scope = args.scope ?? "auto";
+    const trace = createExecutionTrace(stitchExecuteName, {
+      mode: args.mode,
+      prompt: args.prompt,
+      projectTitle: args.projectTitle ?? null,
+      projectId: args.projectId ?? null,
+      screenTitle: args.screenTitle ?? null,
+      scope
+    });
+    trace.selectedSkills.push("stitch-design-orchestrator");
+    trace.selectedReferences.push(
+      "workflows/skills/stitch-design-orchestrator/references/tool-selection.md",
+      "workflows/skills/stitch-design-orchestrator/references/anti-abuse.md"
+    );
+    const gatewayStatus = ctx.gatewayManager.getStatus();
+    const stitchEnabledTools = ctx.gatewayManager.listEnabledTools("stitch");
+    trace.gates.push({
+      name: "gateway_initialized",
+      passed: Boolean(gatewayStatus.providers.stitch),
+      detail: gatewayStatus.providers.stitch?.lastError ?? "Gateway loaded."
+    });
+    trace.gates.push({
+      name: "stitch_enabled_tools",
+      passed: Boolean(stitchEnabledTools.available),
+      detail: stitchEnabledTools.available ? `Enabled tools: ${stitchEnabledTools.enabledCount}` : String(stitchEnabledTools.lastError || "Stitch upstream unavailable.")
+    });
+    const designState = await inspectDesignState(process.cwd());
+    trace.selectedReferences.push(...designState.referencePaths.map((filePath) => path13.relative(process.cwd(), filePath)));
+    trace.gates.push({
+      name: "design_state_ready",
+      passed: designState.ready,
+      detail: designState.detail,
+      action: designState.ready ? void 0 : "Run the design route first and create docs/foundation/DESIGN.md or design overlay docs before Stitch generation."
+    });
+    if (!designState.ready) {
+      const blockedResult = {
+        status: "blocked",
+        recoveredAfterTimeout: false,
+        projectId: args.projectId ?? null,
+        reusedProject: false,
+        reusedScreen: false,
+        artifactSummary: {
+          designReferences: designState.referencePaths.map(
+            (filePath) => path13.relative(process.cwd(), filePath)
+          )
+        },
+        nextSuggestedAction: "Run the design route first, then rerun stitch_execute once design artifacts exist."
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, blockedResult)
+      );
+      return textResult({ ...blockedResult, tracePath });
+    }
+    try {
+      const resolvedProject = await ensureProjectId({
+        projectId: args.projectId,
+        projectTitle: args.projectTitle,
+        scope,
+        trace
+      });
+      const screens = await listProjectScreens({
+        projectId: resolvedProject.projectId,
+        scope,
+        trace
+      });
+      const matchedScreen = args.screenTitle ? findMatchingScreen(screens, args.screenTitle) : null;
+      const effectiveMode = args.mode === "auto" ? matchedScreen ? "edit" : "generate" : args.mode;
+      let toolName = "generate_screen_from_text";
+      let toolArgs = {
+        projectId: resolvedProject.projectId,
+        prompt: args.prompt
+      };
+      if (effectiveMode === "edit") {
+        if (!matchedScreen?.name) {
+          throw new Error(
+            "stitch_execute mode=edit requires an existing screen title in the target project."
+          );
+        }
+        toolName = "edit_screens";
+        toolArgs = {
+          projectId: resolvedProject.projectId,
+          selectedScreenIds: [matchedScreen.name],
+          prompt: args.prompt
+        };
+      } else if (effectiveMode === "variants") {
+        if (!matchedScreen?.name) {
+          throw new Error(
+            "stitch_execute mode=variants requires an existing screen title in the target project."
+          );
+        }
+        toolName = "generate_variants";
+        toolArgs = {
+          projectId: resolvedProject.projectId,
+          selectedScreenIds: [matchedScreen.name],
+          prompt: args.prompt
+        };
+      } else if (args.screenTitle?.trim()) {
+        toolArgs.title = args.screenTitle.trim();
+      }
+      trace.toolCalls.push({
+        name: `stitch.${toolName}`,
+        phase: "execute",
+        outcome: "planned",
+        arguments: toolArgs
+      });
+      const mutationResult = await callUpstreamTool({
+        service: "stitch",
+        name: toolName,
+        argumentsValue: toolArgs,
+        scope
+      });
+      const parsedMutationResult = parseCallToolTextResult(mutationResult);
+      const recoveredAfterTimeout = Boolean(
+        parsedMutationResult.raw?.recoveredAfterTimeout
+      );
+      trace.toolCalls[trace.toolCalls.length - 1].outcome = "success";
+      trace.toolCalls[trace.toolCalls.length - 1].detail = recoveredAfterTimeout ? "Recovered after upstream timeout." : "Mutation completed.";
+      const result = {
+        status: recoveredAfterTimeout ? "recovered_after_timeout" : "success",
+        projectId: resolvedProject.projectId,
+        reusedProject: resolvedProject.reusedProject,
+        reusedScreen: Boolean(matchedScreen),
+        recoveredAfterTimeout,
+        artifactSummary: {
+          designReferences: designState.referencePaths.map(
+            (filePath) => path13.relative(process.cwd(), filePath)
+          ),
+          existingScreens: screens.map((screen) => screen.title || screen.name).filter(Boolean),
+          selectedScreen: matchedScreen?.title || matchedScreen?.name || null
+        },
+        nextSuggestedAction: effectiveMode === "generate" ? "Use stitch_execute mode=edit for refinements once the new screen is visible." : "Inspect the updated screen set and continue with targeted edits if needed.",
+        mutation: parsedMutationResult.raw ?? parsedMutationResult.text
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, result)
+      );
+      return textResult({ ...result, tracePath });
+    } catch (error) {
+      trace.errors.push({ message: String(error) });
+      const failedResult = {
+        status: "failed",
+        recoveredAfterTimeout: false,
+        projectId: args.projectId ?? null,
+        reusedProject: false,
+        reusedScreen: false,
+        artifactSummary: {
+          designReferences: designState.referencePaths.map(
+            (filePath) => path13.relative(process.cwd(), filePath)
+          )
+        },
+        error: String(error)
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, failedResult)
+      );
+      return textResult({ ...failedResult, tracePath });
+    }
+  };
+}
+
+// src/tools/playwrightGetStatus.ts
+import { z as z17 } from "zod";
+var playwrightGetStatusName = "playwright_get_status";
+var playwrightGetStatusDescription = "Get Playwright MCP upstream configuration status including URL and port.";
+var playwrightGetStatusSchema = z17.object({
+  scope: z17.enum(["global", "project", "auto"]).optional().describe(
+    "Config scope to read. Default: auto (project if exists, else global)"
+  )
+});
+function handlePlaywrightGetStatus(args) {
+  const scope = args.scope ?? "auto";
+  const effective = readEffectiveConfig(scope);
+  if (!effective) {
+    configNotFound();
+  }
+  const playwright = parsePlaywrightState(effective.config);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            configured: Boolean(playwright.mcpUrl),
+            mcpUrl: playwright.mcpUrl,
+            port: playwright.port,
+            scope: effective.scope,
+            configPath: effective.path,
+            note: "Playwright MCP runs locally \u2014 no authentication required. Start with: npx @playwright/mcp --port <port>"
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+
+// src/tools/mobileQaRun.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import path14 from "path";
+import { existsSync as existsSync6 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { z as z18 } from "zod";
+var execFileAsync = promisify(execFile);
+var __dirname2 = path14.dirname(fileURLToPath2(import.meta.url));
+var mobileQaRunName = "mobile_qa_run";
+var mobileQaRunDescription = "Run the mobile QA charter runtime with Android MCP as the primary device path, explicit ADB fallback, and persisted execution traces.";
+var mobileQaRunSchema = z18.object({
+  charterPath: z18.string().min(1).describe("Path to the YAML charter file."),
+  apkPath: z18.string().optional().describe("Optional APK path to install before running."),
+  packageId: z18.string().optional().describe("Optional package override."),
+  avdName: z18.string().optional().describe("Optional AVD name to target."),
+  artifactsDir: z18.string().optional().describe("Artifacts directory. Default: artifacts/mobile-qa"),
+  scope: z18.enum(["auto", "global", "project"]).optional(),
+  allowAdbFallback: z18.boolean().optional(),
+  dryRun: z18.boolean().optional()
+});
+function textResult2(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function resolveRunnerPath() {
+  const runtimeRoot = path14.resolve(__dirname2, "..", "..", "runtime");
+  return path14.join(runtimeRoot, "mobile-qa-runner.mjs");
+}
+function isAndroidConfigured(scope) {
+  const effective = readEffectiveConfig(scope);
+  const androidConfig = effective?.config?.android && typeof effective.config.android === "object" && !Array.isArray(effective.config.android) ? effective.config.android : null;
+  return Boolean(androidConfig?.enabled ?? effective?.config?.android);
+}
+function createMobileQaRunHandler(ctx) {
+  return async function handleMobileQaRun(args) {
+    const scope = args.scope ?? "auto";
+    const androidConfigured = isAndroidConfigured(scope);
+    const trace = createExecutionTrace(mobileQaRunName, {
+      charterPath: args.charterPath,
+      apkPath: args.apkPath ?? null,
+      packageId: args.packageId ?? null,
+      avdName: args.avdName ?? null,
+      artifactsDir: args.artifactsDir ?? "artifacts/mobile-qa",
+      scope,
+      allowAdbFallback: Boolean(args.allowAdbFallback),
+      dryRun: Boolean(args.dryRun)
+    });
+    trace.selectedSkills.push("flutter-mobile-qa");
+    trace.selectedReferences.push(
+      "workflows/skills/flutter-mobile-qa/SKILL.md",
+      "workflows/skills/flutter-mobile-qa/references/android-mcp-tools.md"
+    );
+    const gatewayStatus = ctx.gatewayManager.getStatus();
+    const androidTools = ctx.gatewayManager.listEnabledTools("android");
+    trace.gates.push({
+      name: "charter_exists",
+      passed: existsSync6(path14.resolve(args.charterPath)),
+      detail: args.charterPath,
+      action: existsSync6(path14.resolve(args.charterPath)) ? void 0 : "Create the QA charter YAML file and rerun mobile_qa_run."
+    });
+    trace.gates.push({
+      name: "gateway_initialized",
+      passed: Boolean(gatewayStatus.providers.android),
+      detail: gatewayStatus.providers.android?.lastError ?? "Gateway loaded."
+    });
+    trace.gates.push({
+      name: "android_mcp_configured",
+      passed: androidConfigured,
+      detail: androidConfigured ? "Android MCP is configured in cbx_config.json." : "Android MCP is not configured in cbx_config.json.",
+      action: androidConfigured ? void 0 : "Enable android in cbx_config.json or rerun with allowAdbFallback=true."
+    });
+    trace.gates.push({
+      name: "android_enabled_tools",
+      passed: Boolean(androidTools.available),
+      detail: androidTools.available ? `Enabled tools: ${androidTools.enabledCount}` : String(androidTools.lastError || "Android upstream unavailable."),
+      action: androidTools.available ? void 0 : args.allowAdbFallback ? "Android MCP is unavailable, so this run may fall back to ADB." : "Start the Android MCP server or rerun with allowAdbFallback=true."
+    });
+    trace.gates.push({
+      name: "adb_fallback_allowed",
+      passed: Boolean(args.allowAdbFallback),
+      detail: args.allowAdbFallback ? "ADB fallback is enabled for this run." : "ADB fallback is disabled for this run."
+    });
+    if (!existsSync6(path14.resolve(args.charterPath))) {
+      const blockedResult = {
+        status: "blocked",
+        providerPreference: androidConfigured ? "android-mcp" : "adb",
+        providerUsed: null,
+        nextSuggestedAction: "Create the QA charter file first."
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, blockedResult)
+      );
+      return textResult2({ ...blockedResult, tracePath });
+    }
+    if (!androidConfigured && !args.allowAdbFallback) {
+      const blockedResult = {
+        status: "blocked",
+        providerPreference: "android-mcp",
+        providerUsed: null,
+        nextSuggestedAction: "Enable Android MCP in cbx_config.json or rerun with allowAdbFallback=true."
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, blockedResult)
+      );
+      return textResult2({ ...blockedResult, tracePath });
+    }
+    const runnerPath = resolveRunnerPath();
+    const commandArgs = [
+      runnerPath,
+      "--charter",
+      path14.resolve(args.charterPath),
+      "--artifacts-dir",
+      path14.resolve(args.artifactsDir ?? "artifacts/mobile-qa"),
+      "--scope",
+      scope
+    ];
+    if (args.allowAdbFallback) {
+      commandArgs.push("--allow-adb-fallback");
+    }
+    if (args.apkPath) {
+      commandArgs.push("--apk", path14.resolve(args.apkPath));
+    }
+    if (args.packageId) {
+      commandArgs.push("--package", args.packageId);
+    }
+    if (args.avdName) {
+      commandArgs.push("--avd", args.avdName);
+    }
+    if (args.dryRun) {
+      commandArgs.push("--dry-run");
+    }
+    trace.toolCalls.push({
+      name: "mobile-qa-runner",
+      phase: "execute",
+      outcome: "planned",
+      arguments: {
+        charterPath: path14.resolve(args.charterPath),
+        artifactsDir: path14.resolve(args.artifactsDir ?? "artifacts/mobile-qa"),
+        dryRun: Boolean(args.dryRun)
+      }
+    });
+    try {
+      const { stdout } = await execFileAsync(process.execPath, commandArgs, {
+        cwd: process.cwd()
+      });
+      const parsed = JSON.parse(String(stdout || "{}"));
+      trace.toolCalls[trace.toolCalls.length - 1].outcome = "success";
+      if (typeof parsed.reportPath === "string") {
+        trace.artifacts.push({
+          kind: "report",
+          path: parsed.reportPath,
+          description: "Mobile QA report"
+        });
+      }
+      const result = {
+        status: parsed.status ?? "success",
+        providerPreference: androidConfigured ? "android-mcp" : "adb",
+        providerUsed: parsed.providerUsed ?? (androidConfigured ? "android-mcp" : "adb"),
+        artifactSummary: parsed.artifacts ?? {},
+        reportPath: parsed.reportPath ?? null,
+        runnerResult: parsed
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, result)
+      );
+      return textResult2({ ...result, tracePath });
+    } catch (error) {
+      trace.toolCalls[trace.toolCalls.length - 1].outcome = "failed";
+      trace.errors.push({ message: String(error) });
+      const failedResult = {
+        status: "failed",
+        providerPreference: androidConfigured ? "android-mcp" : "adb",
+        providerUsed: androidConfigured ? "android-mcp" : "adb",
+        error: String(error)
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, failedResult)
+      );
+      return textResult2({ ...failedResult, tracePath });
+    }
+  };
+}
+
+// src/tools/webQaRun.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import path15 from "path";
+import { existsSync as existsSync7 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { z as z19 } from "zod";
+var execFileAsync2 = promisify2(execFile2);
+var __dirname3 = path15.dirname(fileURLToPath3(import.meta.url));
+var webQaRunName = "web_qa_run";
+var webQaRunDescription = "Run the web QA charter runtime with Playwright MCP execution, deterministic artifacts, and persisted execution traces.";
+var webQaRunSchema = z19.object({
+  charterPath: z19.string().min(1).describe("Path to the YAML charter file."),
+  artifactsDir: z19.string().optional().describe("Artifacts directory. Default: artifacts/web-qa"),
+  scope: z19.enum(["auto", "global", "project"]).optional(),
+  dryRun: z19.boolean().optional()
+});
+function textResult3(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function resolveRunnerPath2() {
+  const runtimeRoot = path15.resolve(__dirname3, "..", "..", "runtime");
+  return path15.join(runtimeRoot, "web-qa-runner.mjs");
+}
+function createWebQaRunHandler(_ctx) {
+  return async function handleWebQaRun(args) {
+    const scope = args.scope ?? "auto";
+    const trace = createExecutionTrace(webQaRunName, {
+      charterPath: args.charterPath,
+      artifactsDir: args.artifactsDir ?? "artifacts/web-qa",
+      scope,
+      dryRun: Boolean(args.dryRun)
+    });
+    trace.selectedSkills.push("playwright-web-qa");
+    trace.selectedReferences.push(
+      "workflows/skills/playwright-web-qa/SKILL.md",
+      "workflows/skills/playwright-interactive/SKILL.md"
+    );
+    const gatewayStatus = _ctx.gatewayManager.getStatus();
+    const playwrightTools = _ctx.gatewayManager.listEnabledTools("playwright");
+    trace.gates.push({
+      name: "charter_exists",
+      passed: existsSync7(path15.resolve(args.charterPath)),
+      detail: args.charterPath,
+      action: existsSync7(path15.resolve(args.charterPath)) ? void 0 : "Create the QA charter YAML file and rerun web_qa_run."
+    });
+    trace.gates.push({
+      name: "gateway_initialized",
+      passed: Boolean(gatewayStatus.providers.playwright),
+      detail: gatewayStatus.providers.playwright?.lastError ?? "Gateway loaded."
+    });
+    trace.gates.push({
+      name: "playwright_enabled_tools",
+      passed: Boolean(playwrightTools.available),
+      detail: playwrightTools.available ? `Enabled tools: ${playwrightTools.enabledCount}` : String(playwrightTools.lastError || "Playwright upstream unavailable."),
+      action: playwrightTools.available ? void 0 : "Start the Playwright MCP server or configure playwright.mcpUrl in cbx_config.json."
+    });
+    if (!existsSync7(path15.resolve(args.charterPath)) || !playwrightTools.available) {
+      const blockedResult = {
+        status: "blocked",
+        providerPreference: "playwright-mcp",
+        providerUsed: null,
+        nextSuggestedAction: !existsSync7(path15.resolve(args.charterPath)) ? "Create the QA charter file first." : "Start the Playwright MCP server and rerun web_qa_run."
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, blockedResult)
+      );
+      return textResult3({ ...blockedResult, tracePath });
+    }
+    const runnerPath = resolveRunnerPath2();
+    const commandArgs = [
+      runnerPath,
+      "--charter",
+      path15.resolve(args.charterPath),
+      "--artifacts-dir",
+      path15.resolve(args.artifactsDir ?? "artifacts/web-qa"),
+      "--scope",
+      scope
+    ];
+    if (args.dryRun) {
+      commandArgs.push("--dry-run");
+    }
+    trace.toolCalls.push({
+      name: "web-qa-runner",
+      phase: "execute",
+      outcome: "planned",
+      arguments: {
+        charterPath: path15.resolve(args.charterPath),
+        artifactsDir: path15.resolve(args.artifactsDir ?? "artifacts/web-qa"),
+        dryRun: Boolean(args.dryRun)
+      }
+    });
+    try {
+      const { stdout } = await execFileAsync2(process.execPath, commandArgs, {
+        cwd: process.cwd()
+      });
+      const parsed = JSON.parse(String(stdout || "{}"));
+      trace.toolCalls[trace.toolCalls.length - 1].outcome = "success";
+      if (typeof parsed.reportPath === "string") {
+        trace.artifacts.push({
+          kind: "report",
+          path: parsed.reportPath,
+          description: "Web QA report"
+        });
+      }
+      const result = {
+        status: parsed.status ?? "success",
+        providerPreference: "playwright-mcp",
+        providerUsed: parsed.providerUsed ?? "playwright-mcp",
+        artifactSummary: parsed.artifacts ?? {},
+        reportPath: parsed.reportPath ?? null,
+        runnerResult: parsed
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, result)
+      );
+      return textResult3({ ...result, tracePath });
+    } catch (error) {
+      trace.toolCalls[trace.toolCalls.length - 1].outcome = "failed";
+      trace.errors.push({ message: String(error) });
+      const failedResult = {
+        status: "failed",
+        providerPreference: "playwright-mcp",
+        providerUsed: "playwright-mcp",
+        error: String(error)
+      };
+      const tracePath = await persistExecutionTrace(
+        finishExecutionTrace(trace, failedResult)
+      );
+      return textResult3({ ...failedResult, tracePath });
+    }
+  };
+}
+
+// src/tools/mcpGateway.ts
+import { z as z20 } from "zod";
+var postmanListEnabledToolsName = "postman_list_enabled_tools";
+var postmanListEnabledToolsDescription = "List currently enabled Postman upstream passthrough tools and gateway warnings.";
+var postmanListEnabledToolsSchema = z20.object({});
+var stitchListEnabledToolsName = "stitch_list_enabled_tools";
+var stitchListEnabledToolsDescription = "List currently enabled Stitch upstream passthrough tools and gateway warnings.";
+var stitchListEnabledToolsSchema = z20.object({});
+var mcpGatewayStatusName = "mcp_gateway_status";
+var mcpGatewayStatusDescription = "Get passthrough gateway status for Postman and Stitch, including warnings and catalog location.";
+var mcpGatewayStatusSchema = z20.object({});
+function text(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function handlePostmanListEnabledTools(gateway) {
+  return text(gateway.listEnabledTools("postman"));
+}
+function handleStitchListEnabledTools(gateway) {
+  return text(gateway.listEnabledTools("stitch"));
+}
+function handleMcpGatewayStatus(gateway) {
+  return text(gateway.getStatus());
+}
+
+// src/tools/registry.ts
+function withDefaultScope(args, defaultScope) {
+  const safeArgs = args && typeof args === "object" ? args : {};
+  return {
+    ...safeArgs,
+    scope: typeof safeArgs.scope === "string" ? safeArgs.scope : defaultScope
+  };
+}
+var TOOL_REGISTRY = [
+  // ── Route tools ───────────────────────────────────────────
+  {
+    name: routeResolveName,
+    description: routeResolveDescription,
+    schema: routeResolveSchema,
+    category: "route",
+    createHandler: (ctx) => async (args) => handleRouteResolve(
+      args,
+      ctx.routeManifest
+    )
+  },
+  // ── Gateway helper tools ──────────────────────────────────
+  {
+    name: mcpGatewayStatusName,
+    description: mcpGatewayStatusDescription,
+    schema: mcpGatewayStatusSchema,
+    category: "gateway",
+    createHandler: (ctx) => async () => handleMcpGatewayStatus(ctx.gatewayManager)
+  },
+  {
+    name: postmanListEnabledToolsName,
+    description: postmanListEnabledToolsDescription,
+    schema: postmanListEnabledToolsSchema,
+    category: "gateway",
+    createHandler: (ctx) => async () => handlePostmanListEnabledTools(ctx.gatewayManager)
+  },
+  {
+    name: stitchListEnabledToolsName,
+    description: stitchListEnabledToolsDescription,
+    schema: stitchListEnabledToolsSchema,
+    category: "gateway",
+    createHandler: (ctx) => async () => handleStitchListEnabledTools(ctx.gatewayManager)
+  },
+  // ── Skill vault tools ─────────────────────────────────────
+  {
+    name: skillListCategoriesName,
+    description: skillListCategoriesDescription,
+    schema: skillListCategoriesSchema,
+    category: "skill",
+    createHandler: (ctx) => async () => handleSkillListCategories(ctx.manifest, ctx.charsPerToken)
+  },
+  {
+    name: skillBrowseCategoryName,
+    description: skillBrowseCategoryDescription,
+    schema: skillBrowseCategorySchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) => handleSkillBrowseCategory(
+      args,
+      ctx.manifest,
+      ctx.summaryMaxLength,
+      ctx.charsPerToken
+    )
+  },
+  {
+    name: skillSearchName,
+    description: skillSearchDescription,
+    schema: skillSearchSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) => handleSkillSearch(
+      args,
+      ctx.manifest,
+      ctx.summaryMaxLength,
+      ctx.charsPerToken
+    )
+  },
+  {
+    name: skillValidateName,
+    description: skillValidateDescription,
+    schema: skillValidateSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) => handleSkillValidate(
+      args,
+      ctx.manifest,
+      ctx.charsPerToken
+    )
+  },
+  {
+    name: skillGetName,
+    description: skillGetDescription,
+    schema: skillGetSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) => handleSkillGet(
+      args,
+      ctx.manifest,
+      ctx.charsPerToken
+    )
+  },
+  {
+    name: skillGetReferenceName,
+    description: skillGetReferenceDescription,
+    schema: skillGetReferenceSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) => handleSkillGetReference(
+      args,
+      ctx.manifest,
+      ctx.charsPerToken
+    )
+  },
+  {
+    name: skillBudgetReportName,
+    description: skillBudgetReportDescription,
+    schema: skillBudgetReportSchema,
+    category: "skill",
+    createHandler: (ctx) => async (args) => handleSkillBudgetReport(
+      args,
+      ctx.manifest,
+      ctx.charsPerToken
+    )
+  },
+  // ── Postman tools ─────────────────────────────────────────
+  {
+    name: postmanGetModeName,
+    description: postmanGetModeDescription,
+    schema: postmanGetModeSchema,
+    category: "postman",
+    createHandler: (ctx) => async (args) => handlePostmanGetMode(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  {
+    name: postmanSetModeName,
+    description: postmanSetModeDescription,
+    schema: postmanSetModeSchema,
+    category: "postman",
+    createHandler: (ctx) => async (args) => handlePostmanSetMode(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  {
+    name: postmanGetStatusName,
+    description: postmanGetStatusDescription,
+    schema: postmanGetStatusSchema,
+    category: "postman",
+    createHandler: (ctx) => async (args) => handlePostmanGetStatus(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  // ── Stitch tools ──────────────────────────────────────────
+  {
+    name: stitchGetModeName,
+    description: stitchGetModeDescription,
+    schema: stitchGetModeSchema,
+    category: "stitch",
+    createHandler: (ctx) => async (args) => handleStitchGetMode(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  {
+    name: stitchSetProfileName,
+    description: stitchSetProfileDescription,
+    schema: stitchSetProfileSchema,
+    category: "stitch",
+    createHandler: (ctx) => async (args) => handleStitchSetProfile(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  {
+    name: stitchGetStatusName,
+    description: stitchGetStatusDescription,
+    schema: stitchGetStatusSchema,
+    category: "stitch",
+    createHandler: (ctx) => async (args) => handleStitchGetStatus(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  {
+    name: stitchExecuteName,
+    description: stitchExecuteDescription,
+    schema: stitchExecuteSchema,
+    category: "stitch",
+    createHandler: (ctx) => async (args) => createStitchExecuteHandler(ctx)(
+      args
+    )
+  },
+  // ── Playwright tools ──────────────────────────────────────
+  {
+    name: playwrightGetStatusName,
+    description: playwrightGetStatusDescription,
+    schema: playwrightGetStatusSchema,
+    category: "playwright",
+    createHandler: (ctx) => async (args) => handlePlaywrightGetStatus(
+      withDefaultScope(args, ctx.defaultConfigScope)
+    )
+  },
+  {
+    name: mobileQaRunName,
+    description: mobileQaRunDescription,
+    schema: mobileQaRunSchema,
+    category: "mobile",
+    createHandler: (ctx) => async (args) => createMobileQaRunHandler(ctx)(
+      args
+    )
+  },
+  {
+    name: webQaRunName,
+    description: webQaRunDescription,
+    schema: webQaRunSchema,
+    category: "playwright",
+    createHandler: (ctx) => async (args) => createWebQaRunHandler(ctx)(
+      args
+    )
+  }
+];
+
+// src/gateway/catalog.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import os2 from "os";
+import path16 from "path";
+function resolveCatalogDir2(scope, configPath) {
+  if (scope === "project" && configPath) {
+    return path16.join(path16.dirname(configPath), ".cbx", "mcp", "catalog");
+  }
+  return path16.join(os2.homedir(), ".cbx", "mcp", "catalog");
+}
+function catalogFilePath(catalogDir, provider) {
+  return path16.join(catalogDir, `${provider}.tools.json`);
+}
+function persistCatalog2(catalogDir, payload) {
+  mkdirSync2(catalogDir, { recursive: true });
+  const filePath = catalogFilePath(catalogDir, payload.provider);
+  writeFileSync2(filePath, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  return filePath;
+}
+
+// src/gateway/config.ts
+var STITCH_DEFAULT_MCP_URL = "https://stitch.googleapis.com/mcp";
+var PLAYWRIGHT_DEFAULT_PORT = 8931;
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (isNonEmptyString(value)) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function normalizeProfiles(profiles) {
+  if (!profiles) {
+    return [];
+  }
+  if (Array.isArray(profiles)) {
+    return profiles.map((profile, index) => ({
+      name: firstString(profile.name) ?? `profile_${index + 1}`,
+      profile
+    })).filter((entry) => !!entry.profile);
+  }
+  return Object.entries(profiles).map(([name, profile]) => ({
+    name,
+    profile
+  }));
+}
+function selectActiveProfile(profiles, activeProfileName) {
+  if (profiles.length === 0) {
+    return null;
+  }
+  const active = firstString(activeProfileName);
+  if (active) {
+    const hit = profiles.find((profile) => profile.name === active);
+    if (hit) {
+      return hit;
+    }
+  }
+  return profiles[0];
+}
+function buildPostmanConfig(postman, scope, configPath) {
+  const warnings = [];
+  const profiles = normalizeProfiles(postman?.profiles);
+  const active = selectActiveProfile(profiles, postman?.activeProfileName);
+  const mcpUrl = firstString(
+    postman?.mcpUrl,
+    active?.profile.mcpUrl,
+    active?.profile.url
+  );
+  if (!mcpUrl) {
+    warnings.push("Postman MCP URL is not configured (postman.mcpUrl).");
+  }
+  const authEnvVar = firstString(
+    active?.profile.tokenEnvVar,
+    active?.profile.apiKeyEnvVar,
+    postman?.tokenEnvVar,
+    postman?.apiKeyEnvVar
+  );
+  const rawApiKeySet = !!firstString(active?.profile.apiKey);
+  if (rawApiKeySet) {
+    warnings.push(
+      "Postman profile apiKey is ignored; configure apiKeyEnvVar/tokenEnvVar alias instead."
+    );
+  }
+  if (!authEnvVar) {
+    warnings.push(
+      "Postman auth env var alias is missing (active profile apiKeyEnvVar/tokenEnvVar)."
+    );
+    return {
+      provider: "postman",
+      transport: "http",
+      mcpUrl,
+      authHeader: null,
+      authEnvVar: null,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null,
+      scope,
+      configPath,
+      warnings
+    };
+  }
+  const token = process.env[authEnvVar];
+  if (!isNonEmptyString(token)) {
+    warnings.push(`Postman auth env var "${authEnvVar}" is not set.`);
+    return {
+      provider: "postman",
+      transport: "http",
+      mcpUrl,
+      authHeader: null,
+      authEnvVar,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null,
+      scope,
+      configPath,
+      warnings
+    };
+  }
+  return {
+    provider: "postman",
+    transport: "http",
+    mcpUrl,
+    authHeader: { Authorization: `Bearer ${token}` },
+    authEnvVar,
+    command: null,
+    args: [],
+    env: {},
+    cwd: null,
+    scope,
+    configPath,
+    warnings
   };
 }
-async function withUpstreamClient({
-  url,
-  headers,
-  fn
-}) {
-  const client = new Client(
-    {
-      name: "cubis-foundry-mcp-passthrough",
-      version: "0.1.0"
-    },
-    {
-      capabilities: {}
-    }
+function buildStitchConfig(stitch, scope, configPath) {
+  const warnings = [];
+  const profiles = normalizeProfiles(stitch?.profiles);
+  const active = selectActiveProfile(profiles, stitch?.activeProfileName);
+  const mcpUrl = firstString(stitch?.mcpUrl, active?.profile.mcpUrl, active?.profile.url) ?? STITCH_DEFAULT_MCP_URL;
+  const authEnvVar = firstString(
+    active?.profile.apiKeyEnvVar,
+    stitch?.apiKeyEnvVar
   );
-  const transport = new StreamableHTTPClientTransport(new URL(url), {
-    requestInit: { headers }
-  });
-  await client.connect(transport);
-  try {
-    return await fn(client);
-  } finally {
-    await client.close();
+  const rawApiKeySet = !!firstString(active?.profile.apiKey);
+  if (rawApiKeySet) {
+    warnings.push(
+      "Stitch profile apiKey is ignored; configure apiKeyEnvVar alias instead."
+    );
   }
-}
-function isCallToolResult(result) {
-  return Array.isArray(
-    result.content
-  );
-}
-function normalizeUpstreamToolResult(result) {
-  if (isCallToolResult(result)) {
-    return result;
+  if (!authEnvVar) {
+    warnings.push(
+      "Stitch auth env var alias is missing (active profile apiKeyEnvVar)."
+    );
+    return {
+      provider: "stitch",
+      transport: "http",
+      mcpUrl,
+      authHeader: null,
+      authEnvVar: null,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null,
+      scope,
+      configPath,
+      warnings
+    };
+  }
+  const apiKey = process.env[authEnvVar];
+  if (!isNonEmptyString(apiKey)) {
+    warnings.push(`Stitch auth env var "${authEnvVar}" is not set.`);
+    return {
+      provider: "stitch",
+      transport: "http",
+      mcpUrl,
+      authHeader: null,
+      authEnvVar,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null,
+      scope,
+      configPath,
+      warnings
+    };
   }
   return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(
-          {
-            toolResult: result.toolResult
-          },
-          null,
-          2
-        )
-      }
-    ],
-    _meta: result._meta
+    provider: "stitch",
+    transport: "http",
+    mcpUrl,
+    authHeader: { "X-Goog-Api-Key": apiKey },
+    authEnvVar,
+    command: null,
+    args: [],
+    env: {},
+    cwd: null,
+    scope,
+    configPath,
+    warnings
   };
 }
-async function persistCatalog(catalog) {
-  if (!catalog.configPath) return;
-  const catalogDir = resolveCatalogDir(catalog.configPath);
-  const catalogPath = path9.join(catalogDir, `${catalog.service}.json`);
-  const payload = {
-    schemaVersion: 1,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    generatedBy: "cubis-foundry-mcp startup discovery",
-    service: catalog.service,
-    scope: catalog.scope,
-    mcpUrl: catalog.mcpUrl,
-    activeProfileName: catalog.activeProfileName,
-    envVar: catalog.envVar,
-    toolCount: catalog.toolCount,
-    tools: catalog.tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description ?? null,
-      inputSchema: tool.inputSchema ?? null,
-      outputSchema: tool.outputSchema ?? null
-    })),
-    discoveryError: catalog.discoveryError ?? null
+function buildPlaywrightConfig(playwright, scope, configPath) {
+  const warnings = [];
+  const portRaw = playwright?.port ?? PLAYWRIGHT_DEFAULT_PORT;
+  const envPort = process.env.PLAYWRIGHT_MCP_PORT ? Number(process.env.PLAYWRIGHT_MCP_PORT) : void 0;
+  const effectivePort = envPort && Number.isFinite(envPort) && envPort > 0 && envPort < 65536 ? envPort : Number.isFinite(portRaw) && portRaw > 0 && portRaw < 65536 ? portRaw : PLAYWRIGHT_DEFAULT_PORT;
+  const mcpUrl = firstString(playwright?.mcpUrl) ?? `http://localhost:${effectivePort}/mcp`;
+  return {
+    provider: "playwright",
+    transport: "http",
+    mcpUrl,
+    authHeader: {},
+    authEnvVar: null,
+    command: null,
+    args: [],
+    env: {},
+    cwd: null,
+    scope,
+    configPath,
+    warnings
   };
-  await mkdir(catalogDir, { recursive: true });
-  await writeFile(catalogPath, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
 }
-async function discoverUpstreamCatalogs(scope = "auto") {
+function buildAndroidConfig(android, scope, configPath) {
+  const warnings = [];
+  const state = parseAndroidState({ android });
+  if (!state.enabled) {
+    warnings.push("Android MCP is not enabled in cbx_config.json.");
+  }
+  return {
+    provider: "android",
+    transport: "stdio",
+    mcpUrl: null,
+    authHeader: {},
+    authEnvVar: null,
+    command: state.command,
+    args: state.args,
+    env: state.env,
+    cwd: state.cwd,
+    scope,
+    configPath,
+    warnings
+  };
+}
+function resolveGatewayConfig(scope = "auto") {
   const effective = readEffectiveConfig(scope);
   if (!effective) {
-    const missing = {
-      service: "postman",
-      configured: false,
-      mcpUrl: null,
-      activeProfileName: null,
-      envVar: null,
+    const warning = "cbx_config.json not found. Configure Postman/Stitch profiles to enable upstream passthrough.";
+    return {
       scope: null,
       configPath: null,
-      toolCount: 0,
-      tools: [],
-      discoveryError: "cbx_config.json not found"
+      providers: {
+        postman: {
+          provider: "postman",
+          transport: "http",
+          mcpUrl: null,
+          authHeader: null,
+          authEnvVar: null,
+          command: null,
+          args: [],
+          env: {},
+          cwd: null,
+          scope: null,
+          configPath: null,
+          warnings: [warning]
+        },
+        stitch: {
+          provider: "stitch",
+          transport: "http",
+          mcpUrl: STITCH_DEFAULT_MCP_URL,
+          authHeader: null,
+          authEnvVar: null,
+          command: null,
+          args: [],
+          env: {},
+          cwd: null,
+          scope: null,
+          configPath: null,
+          warnings: [warning]
+        },
+        playwright: buildPlaywrightConfig(void 0, null, null),
+        android: buildAndroidConfig(void 0, null, null)
+      }
     };
-    const missingStitch = { ...missing, service: "stitch" };
+  }
+  return {
+    scope: effective.scope,
+    configPath: effective.path,
+    providers: {
+      postman: buildPostmanConfig(
+        effective.config.postman,
+        effective.scope,
+        effective.path
+      ),
+      stitch: buildStitchConfig(
+        effective.config.stitch,
+        effective.scope,
+        effective.path
+      ),
+      playwright: buildPlaywrightConfig(
+        effective.config.playwright,
+        effective.scope,
+        effective.path
+      ),
+      android: buildAndroidConfig(
+        effective.config.android,
+        effective.scope,
+        effective.path
+      )
+    }
+  };
+}
+
+// src/gateway/upstreamClient.ts
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport as StdioClientTransport2 } from "@modelcontextprotocol/sdk/client/stdio.js";
+function toObjectSchema(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+var SdkUpstreamClientFactory = class {
+  async connect(params) {
+    const client = new Client2(
+      {
+        name: "cubis-foundry-mcp-gateway",
+        version: "0.1.0"
+      },
+      { capabilities: {} }
+    );
+    const transport = params.transport === "stdio" ? new StdioClientTransport2({
+      command: params.command || "npx",
+      args: params.args || [],
+      env: params.env || {},
+      cwd: params.cwd || process.cwd(),
+      stderr: "pipe"
+    }) : new StreamableHTTPClientTransport2(new URL(params.mcpUrl || ""), {
+      requestInit: {
+        headers: params.headers || {}
+      }
+    });
+    await client.connect(transport);
     return {
-      postman: missing,
-      stitch: missingStitch
+      async listTools() {
+        const listed = await client.listTools();
+        return listed.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: toObjectSchema(tool.inputSchema)
+        }));
+      },
+      async callTool(toolName, args) {
+        return await client.callTool({
+          name: toolName,
+          arguments: args
+        });
+      },
+      async close() {
+        await client.close();
+      }
     };
   }
-  const baseInfo = {
-    scope: effective.scope,
-    configPath: effective.path
+};
+
+// src/gateway/manager.ts
+function emptyProviderState(provider) {
+  return {
+    provider,
+    transport: provider === "android" ? "stdio" : "http",
+    mcpUrl: null,
+    authEnvVar: null,
+    authConfigured: false,
+    command: null,
+    available: false,
+    warnings: [],
+    lastError: null,
+    syncedAt: null,
+    tools: []
   };
-  const discoverOne = async (service) => {
-    const auth = getServiceAuth(effective.config, service);
-    const catalog = {
-      service,
-      configured: auth.configured,
-      mcpUrl: auth.mcpUrl,
-      activeProfileName: auth.activeProfileName,
-      envVar: auth.envVar,
-      scope: baseInfo.scope,
-      configPath: baseInfo.configPath,
-      toolCount: 0,
-      tools: [],
-      discoveryError: auth.error
+}
+function messageFromError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function normalizeCallResult(result) {
+  if (Array.isArray(result.content)) {
+    return result;
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(result) }],
+    isError: result.isError ?? false,
+    structuredContent: result.structuredContent
+  };
+}
+function normalizeArgs(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) {
+    return {};
+  }
+  return args;
+}
+var GatewayManager = class {
+  clientFactory;
+  providerRuntime = {
+    postman: {
+      transport: "http",
+      mcpUrl: null,
+      headers: null,
+      authEnvVar: null,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null
+    },
+    stitch: {
+      transport: "http",
+      mcpUrl: null,
+      headers: null,
+      authEnvVar: null,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null
+    },
+    playwright: {
+      transport: "http",
+      mcpUrl: null,
+      headers: null,
+      authEnvVar: null,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null
+    },
+    android: {
+      transport: "stdio",
+      mcpUrl: null,
+      headers: {},
+      authEnvVar: null,
+      command: null,
+      args: [],
+      env: {},
+      cwd: null
+    }
+  };
+  providerState = {
+    postman: emptyProviderState("postman"),
+    stitch: emptyProviderState("stitch"),
+    playwright: emptyProviderState("playwright"),
+    android: emptyProviderState("android")
+  };
+  scope = null;
+  configPath = null;
+  catalogDir = resolveCatalogDir2(null, null);
+  constructor(options) {
+    this.clientFactory = options?.clientFactory ?? new SdkUpstreamClientFactory();
+  }
+  async initialize(scope = "auto") {
+    const resolved = resolveGatewayConfig(scope);
+    this.scope = resolved.scope;
+    this.configPath = resolved.configPath;
+    this.catalogDir = resolveCatalogDir2(resolved.scope, resolved.configPath);
+    await Promise.all([
+      this.syncProvider("postman", resolved.providers.postman),
+      this.syncProvider("stitch", resolved.providers.stitch),
+      this.syncProvider("playwright", resolved.providers.playwright),
+      this.syncProvider("android", resolved.providers.android)
+    ]);
+  }
+  getCatalogDir() {
+    return this.catalogDir;
+  }
+  getStatus() {
+    return {
+      scope: this.scope,
+      configPath: this.configPath,
+      catalogDir: this.catalogDir,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      providers: {
+        postman: this.providerState.postman,
+        stitch: this.providerState.stitch,
+        playwright: this.providerState.playwright,
+        android: this.providerState.android
+      }
     };
-    if (!auth.configured || !auth.mcpUrl || auth.error) {
-      const cachedTools = await loadCachedCatalogTools({
-        service,
-        scope: baseInfo.scope,
-        configPath: baseInfo.configPath
+  }
+  listEnabledTools(provider) {
+    const state = this.providerState[provider];
+    return {
+      provider,
+      transport: state.transport,
+      available: state.available,
+      enabledCount: state.tools.length,
+      enabledTools: state.tools.map((tool) => `${provider}.${tool.name}`),
+      upstreamTools: state.tools,
+      warnings: state.warnings,
+      lastError: state.lastError,
+      syncedAt: state.syncedAt,
+      mcpUrl: state.mcpUrl,
+      command: state.command,
+      authEnvVar: state.authEnvVar,
+      authConfigured: state.authConfigured,
+      catalogDir: this.catalogDir
+    };
+  }
+  getDynamicTools(provider) {
+    return [...this.providerState[provider].tools];
+  }
+  async callTool(provider, upstreamToolName, args) {
+    const runtime = this.providerRuntime[provider];
+    if (runtime.transport === "http" && !runtime.mcpUrl) {
+      return errorResult(`${provider} upstream MCP URL is not configured.`);
+    }
+    if (runtime.transport === "stdio" && !runtime.command) {
+      return errorResult(`${provider} upstream stdio command is not configured.`);
+    }
+    if (runtime.transport === "http" && !runtime.headers) {
+      return errorResult(
+        `${provider} upstream auth is not configured via env var alias (${runtime.authEnvVar ?? "missing alias"}).`
+      );
+    }
+    let client = null;
+    try {
+      client = await this.clientFactory.connect({
+        transport: runtime.transport,
+        mcpUrl: runtime.mcpUrl,
+        headers: runtime.headers || {},
+        command: runtime.command,
+        args: runtime.args,
+        env: runtime.env,
+        cwd: runtime.cwd
       });
-      if (cachedTools.length > 0) {
-        catalog.tools = cachedTools;
-        catalog.toolCount = cachedTools.length;
-        catalog.discoveryError = auth.error ? `${auth.error} (using cached tool catalog)` : "Upstream not configured; using cached tool catalog";
+      const result = await client.callTool(
+        upstreamToolName,
+        normalizeArgs(args)
+      );
+      return normalizeCallResult(result);
+    } catch (error) {
+      const message = `${provider}.${upstreamToolName} failed: ${messageFromError(error)}`;
+      logger.warn(message);
+      return errorResult(message);
+    } finally {
+      if (client) {
+        try {
+          await client.close();
+        } catch {
+        }
       }
-      await persistCatalog(catalog);
-      return catalog;
     }
+  }
+  async syncProvider(provider, resolved) {
+    const state = emptyProviderState(provider);
+    state.transport = resolved.transport;
+    state.mcpUrl = resolved.mcpUrl;
+    state.authEnvVar = resolved.authEnvVar;
+    state.authConfigured = resolved.transport === "stdio" ? Boolean(resolved.command) : !!resolved.authHeader;
+    state.command = resolved.command ?? null;
+    state.warnings = [...resolved.warnings];
+    this.providerRuntime[provider] = {
+      transport: resolved.transport,
+      mcpUrl: resolved.mcpUrl,
+      headers: resolved.authHeader,
+      authEnvVar: resolved.authEnvVar,
+      command: resolved.command ?? null,
+      args: resolved.args ?? [],
+      env: resolved.env ?? {},
+      cwd: resolved.cwd ?? null
+    };
+    const unavailable = resolved.transport === "stdio" ? !resolved.command : !resolved.mcpUrl || !resolved.authHeader;
+    if (unavailable) {
+      this.providerState[provider] = state;
+      return;
+    }
+    let client = null;
     try {
-      const listed = await withUpstreamClient({
-        url: auth.mcpUrl,
-        headers: auth.headers,
-        fn: async (client) => client.listTools()
+      client = await this.clientFactory.connect({
+        transport: resolved.transport,
+        mcpUrl: resolved.mcpUrl,
+        headers: resolved.authHeader || {},
+        command: resolved.command ?? null,
+        args: resolved.args ?? [],
+        env: resolved.env ?? {},
+        cwd: resolved.cwd ?? null
       });
-      const rawTools = Array.isArray(listed.tools) ? listed.tools : [];
-      catalog.tools = rawTools.map((tool) => buildUpstreamToolInfo(service, tool || {})).filter((tool) => Boolean(tool));
-      catalog.toolCount = catalog.tools.length;
-    } catch (error) {
-      catalog.discoveryError = `Tool discovery failed: ${String(error)}`;
-      const cachedTools = await loadCachedCatalogTools({
-        service,
-        scope: baseInfo.scope,
-        configPath: baseInfo.configPath
+      const tools = await client.listTools();
+      const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+      state.tools = tools;
+      state.available = true;
+      state.syncedAt = syncedAt;
+      persistCatalog2(this.catalogDir, {
+        provider,
+        mcpUrl: resolved.mcpUrl ?? `stdio:${resolved.command ?? "unknown"}`,
+        syncedAt,
+        tools: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        }))
       });
-      if (cachedTools.length > 0) {
-        catalog.tools = cachedTools;
-        catalog.toolCount = cachedTools.length;
-        catalog.discoveryError = `${catalog.discoveryError} (using cached tool catalog)`;
+    } catch (error) {
+      state.lastError = messageFromError(error);
+      state.warnings.push(
+        `${provider} upstream unavailable: ${state.lastError}`
+      );
+      state.available = false;
+      state.tools = [];
+      logger.warn(`${provider} gateway init failed: ${state.lastError}`);
+    } finally {
+      if (client) {
+        try {
+          await client.close();
+        } catch {
+        }
       }
     }
-    await persistCatalog(catalog);
-    return catalog;
-  };
-  return {
-    postman: await discoverOne("postman"),
-    stitch: await discoverOne("stitch")
-  };
-}
-async function callUpstreamTool({
-  service,
-  name,
-  argumentsValue,
-  scope = "auto"
-}) {
-  const effective = readEffectiveConfig(scope);
-  if (!effective) {
-    throw new Error("cbx_config.json not found");
-  }
-  const auth = getServiceAuth(effective.config, service);
-  if (!auth.configured || !auth.mcpUrl) {
-    throw new Error(auth.error || `${service} is not configured`);
+    this.providerState[provider] = state;
   }
-  if (auth.error) {
-    throw new Error(auth.error);
-  }
-  return withUpstreamClient({
-    url: auth.mcpUrl,
-    headers: auth.headers,
-    fn: async (client) => normalizeUpstreamToolResult(
-      await client.callTool({
-        name,
-        arguments: argumentsValue
-      })
-    )
-  });
-}
+};
 
 // src/server.ts
 function toolCallErrorResult({
@@ -2631,9 +4635,12 @@ async function createServer({
     name: config.server.name,
     version: config.server.version
   });
+  const gatewayManager = new GatewayManager();
+  await gatewayManager.initialize(defaultConfigScope);
   const runtimeCtx = {
     manifest,
     routeManifest,
+    gatewayManager,
     charsPerToken: config.telemetry?.charsPerToken ?? 4,
     summaryMaxLength: config.vault.summaryMaxLength,
     defaultConfigScope
@@ -2654,9 +4661,14 @@ async function createServer({
     `Registered ${TOOL_REGISTRY.length} built-in tools from registry`
   );
   const upstreamCatalogs = await discoverUpstreamCatalogs(defaultConfigScope);
-  const dynamicSchema = z16.object({}).passthrough();
+  const dynamicSchema = z21.object({}).passthrough();
   const registeredDynamicToolNames = /* @__PURE__ */ new Set();
-  for (const catalog of [upstreamCatalogs.postman, upstreamCatalogs.stitch]) {
+  for (const catalog of [
+    upstreamCatalogs.postman,
+    upstreamCatalogs.stitch,
+    upstreamCatalogs.playwright,
+    upstreamCatalogs.android
+  ]) {
     for (const tool of catalog.tools) {
       const registrationNames = [
         tool.namespacedName,
@@ -2887,9 +4899,9 @@ function createMultiSessionHttpServer(options, serverFactory) {
 }
 
 // src/index.ts
-import path10 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
+import path17 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __dirname4 = path17.dirname(fileURLToPath4(import.meta.url));
 function parseArgs(argv) {
   let transport = "stdio";
   let scope = "auto";
@@ -2971,9 +4983,11 @@ function printConfigStatus(scope) {
     }
     const stitchState = parseStitchState(config);
     const stitchProfile = stitchState.activeProfileName;
-    if (stitchProfile && stitchState.activeProfile?.url) {
-      const url = stitchState.activeProfile.url ?? "(no URL)";
-      logger.info(`Stitch profile: ${stitchProfile} (${url})`);
+    const stitchUrl = stitchState.mcpUrl ?? stitchState.activeProfile?.url;
+    if (stitchProfile && stitchUrl) {
+      logger.info(`Stitch profile: ${stitchProfile} (${stitchUrl})`);
+    } else if (stitchUrl) {
+      logger.info(`Stitch: configured (${stitchUrl})`);
     } else {
       logger.info("Stitch: not configured");
     }
@@ -2988,7 +5002,8 @@ async function main() {
     setLogLevel("debug");
   }
   const serverConfig = loadServerConfig(args.configPath);
-  const basePath = path10.resolve(__dirname2, "..");
+  const basePath = path17.resolve(__dirname4, "..");
+  assertBuildFreshness(basePath);
   const scannedSkills = await scanVaultRoots(serverConfig.vault.roots, basePath);
   const generatedSkillManifest = await loadGeneratedSkillManifest(basePath);
   const skills = mergeGeneratedSkillMetadata(