nexus-agents 8.131.1 → 8.131.3

package/dist/{chunk-45AUQYWF.js → chunk-UETCXCAS.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-M7FO5W7A.js";
 import {
   withPrerequisite
-} from "./chunk-2B55IL7S.js";
+} from "./chunk-AAE7F4CB.js";
 import {
   generateSecurityPlan
 } from "./chunk-R4AH6LIE.js";
@@ -41,7 +41,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-NEB2FSBW.js";
+} from "./chunk-5XMXBSPY.js";
 import {
   executeExpert
 } from "./chunk-VL65KGVM.js";
@@ -96,7 +96,7 @@ import {
   withFileLock,
   withWarnings,
   writeJobCancelled
-} from "./chunk-DFAT7RB7.js";
+} from "./chunk-FB4ZIOYS.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -112,22 +112,23 @@ import {
   getMcpAnnotations,
   getToolAnnotations,
   getToolTimeout,
+  registerStructuredTool,
   resolvePolicyRolloutMode,
   sanitizeToolInput,
+  structuredToolSuccess,
   toSdkCallback,
   toSdkCallbackWithTimeoutCheck,
   toolError,
   toolStructuredError,
   toolSuccess,
-  toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-QGXA3QXW.js";
+} from "./chunk-CGKENW3F.js";
 import {
   VERSION,
   createRequestContext,
   measuredTrustTier
-} from "./chunk-ETJY6TMK.js";
+} from "./chunk-RWWPMTJK.js";
 import {
   allOf,
   anyOf
@@ -37873,7 +37874,7 @@ function errorResult(text) {
   return toolError(text);
 }
 function successResultStructured(data) {
-  return toolSuccessStructured(data);
+  return structuredToolSuccess(DelegateOutputSchema, data);
 }
 function buildDelegateOutput(selection, requirements) {
   const caps = MODEL_CAPABILITIES2[selection.model];
@@ -38051,6 +38052,9 @@ function classifyDelegateGovernance(input, logger59) {
 }
 function enrichWithGovernance(output2, governance) {
   if (!governance.promoted) return output2;
+  if (governance.votingThreshold === null || governance.promotionReason === null) {
+    throw new Error("Promoted governance requires a voting threshold and promotion reason");
+  }
   return {
     ...output2,
     governance: {
@@ -38155,7 +38159,8 @@ function registerDelegateToModelTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "delegate_to_model",
     {
       description: "Pick which EXISTING model should handle a task. Inspects task complexity and returns the best-fit model from the routing registry \u2014 does NOT add a new model. Records the routing decision to tool-memory for learning feedback (not a pure read). (For drafting a registry entry for a new model, use `registry_import`.)",
@@ -39096,6 +39101,17 @@ function standardReportHandler(state) {
 
 // src/mcp/tools/list-experts.ts
 import { z as z65 } from "zod";
+var OUTPUT_SCHEMA = {
+  experts: z65.array(
+    z65.object({
+      role: z65.string(),
+      name: z65.string(),
+      description: z65.string(),
+      capabilities: z65.array(z65.string())
+    })
+  ),
+  count: z65.number()
+};
 var ListExpertsInputSchema = z65.object({
   format: z65.enum(["full", "names"]).optional().default("full").describe("Output format: full (with details) or names (just role names)")
 });
@@ -39162,8 +39178,7 @@ function listExpertsHandler(args, ctx) {
   }
   const result = handleListExperts(validationResult.data);
   ctx.logger.debug("Listed available experts", { count: result.count });
-  const data = result;
-  return Promise.resolve(toolSuccessStructured(data));
+  return Promise.resolve(structuredToolSuccess(z65.object(OUTPUT_SCHEMA), result));
 }
 function registerListExpertsTool(server, deps) {
   const logger59 = deps.logger ?? createLogger({ tool: "list_experts" });
@@ -39178,23 +39193,13 @@ function registerListExpertsTool(server, deps) {
   });
   const timeoutMs = getToolTimeout("list_experts", deps.security);
   const wrappedHandler = wrapToolWithTimeout("list_experts", secureHandler, { timeoutMs, logger: logger59 });
-  const outputSchema = {
-    experts: z65.array(
-      z65.object({
-        role: z65.string(),
-        name: z65.string(),
-        description: z65.string(),
-        capabilities: z65.array(z65.string())
-      })
-    ),
-    count: z65.number()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "list_experts",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA,
       annotations: getToolAnnotations("list_experts")
     },
     toSdkCallback(wrappedHandler)
@@ -39204,6 +39209,18 @@ function registerListExpertsTool(server, deps) {
 
 // src/mcp/tools/list-workflows.ts
 import { z as z66 } from "zod";
+var OUTPUT_SCHEMA2 = {
+  workflows: z66.array(
+    z66.object({
+      name: z66.string(),
+      version: z66.string(),
+      description: z66.string().optional(),
+      category: z66.string().optional()
+    })
+  ),
+  count: z66.number(),
+  categories: z66.array(z66.string()).optional()
+};
 var ListWorkflowsInputSchema = z66.object({
   category: z66.string().optional().describe("Filter by category (e.g., development, security)"),
   format: z66.enum(["full", "names"]).optional().default("full").describe("Output format: full (with details) or names (just template names)")
@@ -39252,8 +39269,7 @@ function createListWorkflowsHandler(workflowEngine) {
         count: result.count,
         category: validationResult.data.category
       });
-      const data = result;
-      return toolSuccessStructured(data);
+      return structuredToolSuccess(z66.object(OUTPUT_SCHEMA2), result);
     });
   };
 }
@@ -39275,24 +39291,13 @@ function registerListWorkflowsTool(server, deps) {
     secureHandler,
     timeoutMs !== void 0 ? { timeoutMs, logger: logger59 } : { logger: logger59 }
   );
-  const outputSchema = {
-    workflows: z66.array(
-      z66.object({
-        name: z66.string(),
-        version: z66.string(),
-        description: z66.string().optional(),
-        category: z66.string().optional()
-      })
-    ),
-    count: z66.number(),
-    categories: z66.array(z66.string()).optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "list_workflows",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA2,
       annotations: getToolAnnotations("list_workflows")
     },
     toSdkCallback(wrappedHandler)
@@ -40151,7 +40156,7 @@ function createResearchQueryHandler(deps) {
           reason: result.negativeResults.reason
         });
       }
-      return toolSuccessStructured(result);
+      return structuredToolSuccess(z70.object(ResearchQueryOutputSchema), result);
     });
   };
 }
@@ -40175,7 +40180,8 @@ function registerResearchQueryTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_query",
     {
       description,
@@ -40190,6 +40196,13 @@ function registerResearchQueryTool(server, deps) {
 
 // src/mcp/tools/research-add.ts
 import { z as z71 } from "zod";
+var OUTPUT_SCHEMA3 = {
+  success: z71.boolean(),
+  paperId: z71.string().optional(),
+  title: z71.string().optional(),
+  message: z71.string(),
+  dryRun: z71.boolean().optional()
+};
 var ResearchAddInputSchema = z71.object({
   arxivId: z71.string().regex(/^\d{4}\.\d{4,5}$/, "Invalid arXiv ID format (expected XXXX.XXXXX)").describe('arXiv paper ID (e.g., "2401.12345")'),
   topic: z71.string().optional().describe("Research topic to categorize the paper under"),
@@ -40255,7 +40268,8 @@ function createResearchAddHandler(deps) {
           message: result.message
         });
       }
-      return toolSuccessStructured(result);
+      const { errorCategory: _errorCategory, ...data } = result;
+      return structuredToolSuccess(z71.object(OUTPUT_SCHEMA3), data);
     });
   };
 }
@@ -40278,19 +40292,13 @@ function registerResearchAddTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  const outputSchema = {
-    success: z71.boolean(),
-    paperId: z71.string().optional(),
-    title: z71.string().optional(),
-    message: z71.string(),
-    dryRun: z71.boolean().optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_add",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA3,
       annotations: getToolAnnotations("research_add")
     },
     toSdkCallback(wrappedHandler)
@@ -40321,7 +40329,9 @@ var ResearchAddSourceInputSchema = z72.object({
     has_tests: z72.boolean().optional(),
     has_docs: z72.boolean().optional(),
     has_paper: z72.boolean().optional()
-  }).optional().describe("Quality signals used to compute quality_score; provide explicitly \u2014 no GitHub metadata is fetched"),
+  }).optional().describe(
+    "Quality signals used to compute quality_score; provide explicitly \u2014 no GitHub metadata is fetched"
+  ),
   techniques_extracted: z72.array(z72.string().max(100)).max(5).optional().describe("Techniques identified in this source (max 5)"),
   verdict: VerdictEnum.optional().describe("Adoption verdict"),
   verdict_notes: z72.string().max(500).optional().describe("Notes explaining the verdict"),
@@ -40458,7 +40468,8 @@ function createResearchAddSourceHandler(deps) {
           message: result.message
         });
       }
-      return toolSuccessStructured(result);
+      const { errorCategory: _errorCategory, ...data } = result;
+      return structuredToolSuccess(z72.object(RESEARCH_ADD_SOURCE_OUTPUT_SCHEMA), data);
     });
   };
 }
@@ -40495,7 +40506,8 @@ function registerResearchAddSourceTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_add_source",
     {
       description,
@@ -40800,7 +40812,7 @@ function createResearchDiscoverHandler(deps) {
     const startMs = Date.now();
     const response = await withToolError("Discovery failed", logger59, async () => {
       const result = await executeDiscovery(validationResult.data, logger59);
-      return toolSuccessStructured(result);
+      return structuredToolSuccess(z73.object(RESEARCH_DISCOVER_OUTPUT_SCHEMA), result);
     });
     const durationMs = Date.now() - startMs;
     if (response.isError === true) {
@@ -40843,7 +40855,8 @@ function registerResearchDiscoverTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_discover",
     {
       description,
@@ -40869,6 +40882,12 @@ var RESEARCH_DISCOVER_OUTPUT_SCHEMA = {
 
 // src/mcp/tools/research-analyze.ts
 import { z as z74 } from "zod";
+var OUTPUT_SCHEMA4 = {
+  focus: z74.string().optional(),
+  success: z74.boolean().optional(),
+  analysis: z74.unknown().optional(),
+  recommendations: z74.array(z74.string()).optional()
+};
 var ResearchAnalyzeInputSchema = z74.object({
   focus: z74.enum(["gaps", "trends", "priorities", "stale", "coverage"]).describe(
     "Analysis focus: gaps (missing coverage), trends (topic distribution), priorities (P1/P2 backlog), stale (outdated entries), coverage (implementation status)"
@@ -41112,7 +41131,7 @@ function createResearchAnalyzeHandler(deps) {
     const logger59 = deps.logger ?? createLogger({ tool: "research_analyze" });
     return withToolError("Analysis failed", logger59, async () => {
       const result = await executeAnalysis(validationResult.data);
-      return toolSuccessStructured(result);
+      return structuredToolSuccess(z74.object(OUTPUT_SCHEMA4), result);
     });
   };
 }
@@ -41133,18 +41152,13 @@ function registerResearchAnalyzeTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  const outputSchema = {
-    focus: z74.string().optional(),
-    success: z74.boolean().optional(),
-    analysis: z74.unknown().optional(),
-    recommendations: z74.array(z74.string()).optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_analyze",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA4,
       annotations: getToolAnnotations("research_analyze")
     },
     toSdkCallback(wrappedHandler)
@@ -41154,6 +41168,12 @@ function registerResearchAnalyzeTool(server, deps) {
 
 // src/mcp/tools/research-catalog-review.ts
 import { z as z75 } from "zod";
+var OUTPUT_SCHEMA5 = {
+  action: z75.string().optional(),
+  success: z75.boolean().optional(),
+  message: z75.string().optional(),
+  data: z75.unknown().optional()
+};
 var ResearchCatalogReviewInputSchema = z75.object({
   action: z75.enum(["list", "approve", "dismiss", "flush"]).describe(
     "Action: list (show pending), approve (add to registry), dismiss (remove), flush (clear all)"
@@ -41285,7 +41305,7 @@ function createCatalogReviewHandler(deps) {
       if (!result.success) {
         return toolStructuredError({ errorCategory: "validation", message: result.message });
       }
-      return toolSuccessStructured(result);
+      return structuredToolSuccess(z75.object(OUTPUT_SCHEMA5), result);
     });
   };
 }
@@ -41308,18 +41328,13 @@ function registerResearchCatalogReviewTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  const outputSchema = {
-    action: z75.string().optional(),
-    success: z75.boolean().optional(),
-    message: z75.string().optional(),
-    data: z75.unknown().optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_catalog_review",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA5,
       annotations: getToolAnnotations("research_catalog_review")
     },
     toSdkCallback(wrappedHandler)
@@ -41329,6 +41344,14 @@ function registerResearchCatalogReviewTool(server, deps) {
 
 // src/mcp/tools/research-synthesize.ts
 import { z as z76 } from "zod";
+var OUTPUT_SCHEMA6 = {
+  clusters: z76.array(z76.unknown()).optional(),
+  totalPapers: z76.number().optional(),
+  topicCount: z76.number().optional(),
+  crossCuttingThemes: z76.array(z76.unknown()).optional(),
+  alignmentSummary: z76.unknown().optional(),
+  featureGates: z76.array(z76.unknown()).optional()
+};
 var ResearchSynthesizeInputSchema = z76.object({
   topic: z76.string().optional().describe("Optional topic to filter synthesis to a single cluster")
 });
@@ -41350,7 +41373,7 @@ function createResearchSynthesizeHandler(deps) {
           message: `Synthesis failed: ${result.error.message}`
         });
       }
-      return toolSuccessStructured(result.value);
+      return structuredToolSuccess(z76.object(OUTPUT_SCHEMA6), result.value);
     });
   };
 }
@@ -41370,20 +41393,13 @@ function registerResearchSynthesizeTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  const outputSchema = {
-    clusters: z76.array(z76.unknown()).optional(),
-    totalPapers: z76.number().optional(),
-    topicCount: z76.number().optional(),
-    crossCuttingThemes: z76.array(z76.unknown()).optional(),
-    alignmentSummary: z76.unknown().optional(),
-    featureGates: z76.array(z76.unknown()).optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "research_synthesize",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA6,
       annotations: getToolAnnotations("research_synthesize")
     },
     toSdkCallback(wrappedHandler)
@@ -42531,6 +42547,21 @@ function recordSpecOutcome(success, durationMs, stage) {
 
 // src/mcp/tools/memory-query.ts
 import { z as z80 } from "zod";
+var OUTPUT_SCHEMA7 = {
+  query: z80.string(),
+  expandedQuery: z80.string().optional(),
+  results: z80.array(z80.unknown()),
+  count: z80.number(),
+  source: z80.string(),
+  // #4999: the SDK validates structured content against this schema with
+  // `additionalProperties: false`, so a field added to the response and not
+  // declared here makes EVERY call fail with -32602 rather than merely going
+  // unreported. The integration test caught that; the unit tests could not,
+  // because they call the handler directly and never cross the protocol.
+  searched: z80.array(z80.string()),
+  unavailable: z80.array(z80.string()),
+  errored: z80.array(z80.string())
+};
 var MemoryQueryInputSchema = z80.object({
   query: z80.string().min(1).max(500).describe("Search query to match against memory contents"),
   limit: z80.number().int().min(1).max(50).optional().default(10).describe("Maximum results to return (default: 10, max: 50)"),
@@ -42635,7 +42666,7 @@ async function memoryQueryHandler(args, ctx) {
   }
   return withToolError("Memory query failed", ctx.logger, async () => {
     const result = await executeMemoryQuery(validationResult.data, ctx.logger);
-    return toolSuccessStructured(result);
+    return structuredToolSuccess(z80.object(OUTPUT_SCHEMA7), result);
   });
 }
 function registerMemoryQueryTool(server, deps) {
@@ -42653,27 +42684,13 @@ function registerMemoryQueryTool(server, deps) {
   });
   const timeoutMs = getToolTimeout("memory_query", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_query", secureHandler, { timeoutMs, logger: logger59 });
-  const outputSchema = {
-    query: z80.string(),
-    expandedQuery: z80.string().optional(),
-    results: z80.array(z80.unknown()),
-    count: z80.number(),
-    source: z80.string(),
-    // #4999: the SDK validates structured content against this schema with
-    // `additionalProperties: false`, so a field added to the response and not
-    // declared here makes EVERY call fail with -32602 rather than merely going
-    // unreported. The integration test caught that; the unit tests could not,
-    // because they call the handler directly and never cross the protocol.
-    searched: z80.array(z80.string()),
-    unavailable: z80.array(z80.string()),
-    errored: z80.array(z80.string())
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "memory_query",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA7,
       annotations: getToolAnnotations("memory_query")
     },
     toSdkCallback(wrappedHandler)
@@ -42683,6 +42700,16 @@ function registerMemoryQueryTool(server, deps) {
 
 // src/mcp/tools/memory-stats.ts
 import { z as z81 } from "zod";
+var OUTPUT_SCHEMA8 = {
+  backends: z81.unknown(),
+  session: z81.unknown().optional(),
+  belief: z81.unknown().optional(),
+  typed: z81.unknown().optional(),
+  mobimem: z81.unknown().optional(),
+  decay: z81.unknown().optional(),
+  registry: z81.array(z81.unknown()).optional(),
+  collectedAt: z81.string().optional()
+};
 var MemoryStatsInputSchema = z81.object({
   includeDecay: z81.boolean().optional().default(true).describe("Include decay statistics (default: true)")
 });
@@ -42795,7 +42822,7 @@ async function memoryStatsHandler(args, ctx) {
   }
   return withToolError("Memory stats failed", ctx.logger, async () => {
     const result = await collectMemoryStats(validationResult.data, ctx.logger);
-    return toolSuccessStructured(result);
+    return structuredToolSuccess(z81.object(OUTPUT_SCHEMA8), result);
   });
 }
 function registerMemoryStatsTool(server, deps) {
@@ -42811,22 +42838,13 @@ function registerMemoryStatsTool(server, deps) {
   });
   const timeoutMs = getToolTimeout("memory_stats", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_stats", secureHandler, { timeoutMs, logger: logger59 });
-  const outputSchema = {
-    backends: z81.unknown(),
-    session: z81.unknown().optional(),
-    belief: z81.unknown().optional(),
-    typed: z81.unknown().optional(),
-    mobimem: z81.unknown().optional(),
-    decay: z81.unknown().optional(),
-    registry: z81.array(z81.unknown()).optional(),
-    collectedAt: z81.string().optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "memory_stats",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA8,
       annotations: getToolAnnotations("memory_stats")
     },
     toSdkCallback(wrappedHandler)
@@ -42836,6 +42854,13 @@ function registerMemoryStatsTool(server, deps) {
 
 // src/mcp/tools/memory-write.ts
 import { z as z82 } from "zod";
+var OUTPUT_SCHEMA9 = {
+  success: z82.boolean(),
+  backend: z82.string(),
+  key: z82.string(),
+  deduplicated: z82.boolean().optional(),
+  error: z82.string().optional()
+};
 var SOURCE_TRUST_TIER_DESCRIPTION = "Trust tier ('1'-'4') of where the content came from: '1' only for content the caller authored or took from repo files, '3' for external web or issue text. Omitted means '3'. The stored tier is the least-trusted of this and the caller's measured tier, so it can lower trust, never raise it; when the caller is unmeasured, a declaration counts as at most '3'.";
 var MemoryWriteInputSchema = z82.object({
   key: z82.string().min(1).max(200).describe("Memory identifier or subject"),
@@ -43026,7 +43051,7 @@ async function memoryWriteHandler(args, ctx) {
         message: JSON.stringify(result, null, 2)
       });
     }
-    return toolSuccessStructured(result);
+    return structuredToolSuccess(z82.object(OUTPUT_SCHEMA9), result);
   });
 }
 function registerMemoryWriteTool(server, deps) {
@@ -43050,19 +43075,13 @@ function registerMemoryWriteTool(server, deps) {
   const guardedHandler = withPrerequisite("memory_write", secureHandler);
   const timeoutMs = getToolTimeout("memory_write", deps.security);
   const wrappedHandler = wrapToolWithTimeout("memory_write", guardedHandler, { timeoutMs, logger: logger59 });
-  const outputSchema = {
-    success: z82.boolean(),
-    backend: z82.string(),
-    key: z82.string(),
-    deduplicated: z82.boolean().optional(),
-    error: z82.string().optional()
-  };
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "memory_write",
     {
       description,
       inputSchema: toolSchema,
-      outputSchema,
+      outputSchema: OUTPUT_SCHEMA9,
       annotations: getToolAnnotations("memory_write")
     },
     toSdkCallback(wrappedHandler)
@@ -43342,8 +43361,9 @@ function weatherReportHandler(args, ctx) {
     };
     const report = generateWeatherReport(opts);
     const serialized = serializeReport(report);
-    const data = serialized;
-    return Promise.resolve(toolSuccessStructured(data));
+    return Promise.resolve(
+      structuredToolSuccess(z84.object(WEATHER_REPORT_OUTPUT_SCHEMA), serialized)
+    );
   } catch (caught) {
     return Promise.resolve(toolErrorResponse("Weather report failed", caught, ctx.logger));
   }
@@ -43372,12 +43392,12 @@ function registerWeatherReportTool(server, deps) {
     rateLimiter: deps.rateLimiter,
     logger: logger59
   });
-  const timeoutMs = getToolTimeout("weather_report", deps.security);
   const wrappedHandler = wrapToolWithTimeout("weather_report", secureHandler, {
-    timeoutMs,
+    timeoutMs: getToolTimeout("weather_report", deps.security),
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "weather_report",
     {
       description,
@@ -47304,7 +47324,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-K4SNLVKO.js");
+    const { executeVoting } = await import("./consensus-vote-6ISHSQ73.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -49133,7 +49153,7 @@ function createVoteStage({ config, startStage }) {
     const strategy = config.votingStrategy ?? "higher_order";
     await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
     try {
-      const { executeVoting } = await import("./consensus-vote-K4SNLVKO.js");
+      const { executeVoting } = await import("./consensus-vote-6ISHSQ73.js");
       const proposal = buildVoteProposal(plan, research);
       const votingResult = await executeVoting(
         {
@@ -52112,7 +52132,7 @@ function createSurveyHandler(deps) {
     });
     return withToolError("Survey failed", logger59, async () => {
       const result = await executeSurvey(validation.data, logger59);
-      return toolSuccessStructured(result);
+      return structuredToolSuccess(z104.object(SURVEY_OUTPUT_SCHEMA), result);
     });
   };
 }
@@ -52136,7 +52156,8 @@ function registerSurveyOssLandscapeTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "survey_oss_landscape",
     {
       description: SURVEY_DESCRIPTION,
@@ -52251,7 +52272,9 @@ function createVendorPublishingAuditHandler(deps) {
     ctx.logger.debug("Vendor publishing audit", { vendor: validation.data.vendor });
     return withToolError("Vendor publishing audit failed", logger59, () => {
       const result = lookupVendor(validation.data.vendor);
-      return Promise.resolve(toolSuccessStructured(result));
+      return Promise.resolve(
+        structuredToolSuccess(z105.object(VENDOR_PUBLISHING_OUTPUT_SCHEMA), result)
+      );
     });
   };
 }
@@ -52284,7 +52307,8 @@ function registerVendorPublishingAuditTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "vendor_publishing_audit",
     {
       description: VENDOR_PUBLISHING_DESCRIPTION,
@@ -52486,7 +52510,7 @@ function createCompareDataFeedsHandler(deps) {
     });
     return withToolError("Compare data feeds failed", logger59, () => {
       const result = executeCompare(validation.data);
-      return Promise.resolve(toolSuccessStructured(result));
+      return Promise.resolve(structuredToolSuccess(z106.object(COMPARE_OUTPUT_SCHEMA), result));
     });
   };
 }
@@ -52523,7 +52547,8 @@ function registerCompareDataFeedsTool(server, deps) {
     timeoutMs,
     logger: logger59
   });
-  server.registerTool(
+  registerStructuredTool(
+    server,
     "compare_data_feeds",
     {
       description: COMPARE_DESCRIPTION,
@@ -54835,7 +54860,7 @@ async function executeDevPipelineBody(taskText, stages, pipelineOptions, simulat
       detail: output2
     });
   }
-  return toolSuccessStructured(output2);
+  return structuredToolSuccess(z115.record(z115.string(), z115.unknown()), output2);
 }
 function describeIncompleteRun(result) {
   if (result.planStatus !== void 0) {
@@ -55113,7 +55138,7 @@ async function executePipelineBody(task, stages, run) {
       detail: output2
     });
   }
-  return toolSuccessStructured(output2);
+  return structuredToolSuccess(z116.record(z116.string(), z116.unknown()), output2);
 }
 function createPipelineAgentStages(input, config) {
   return createAgentStages({
@@ -56060,8 +56085,8 @@ function createAnnotationsProxy(server) {
 }
 
 // src/mcp/workspace-roots.ts
-import { existsSync as existsSync16 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync16, realpathSync as realpathSync6, statSync as statSync4 } from "node:fs";
+import { isAbsolute as isAbsolute6, join as join17 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function deriveWorkspaceRootFromRoots(roots) {
@@ -56083,19 +56108,39 @@ function deriveWorkspaceRootFromRoots(roots) {
 var WORKSPACE_ROOT_READY_TIMEOUT_MS = 1e3;
 var workspaceRootReady = Promise.resolve();
 var resolution;
+function resolveClaudeProjectRoot(logger59) {
+  const candidate = process.env["CLAUDE_PROJECT_DIR"];
+  if (candidate === void 0) return null;
+  try {
+    if (isAbsolute6(candidate)) {
+      const canonical = realpathSync6(candidate);
+      const root = statSync4(canonical).isDirectory() ? findRepoRoot(canonical) : null;
+      if (root !== null && setActiveWorkspaceRoot(root)) return root;
+    }
+  } catch {
+  }
+  logger59.warn("Invalid CLAUDE_PROJECT_DIR; falling back to MCP client roots");
+  return null;
+}
 function beginWorkspaceRootResolution(logger59) {
   if (resolution?.timer !== void 0) clearTimeout(resolution.timer);
   let resolveReady;
   workspaceRootReady = new Promise((resolve13) => {
     resolveReady = resolve13;
   });
+  const root = resolveClaudeProjectRoot(logger59);
   resolution = {
     logger: logger59,
     fallbackRoot: findRepoRoot(process.cwd()) ?? homedir3(),
     resolve: resolveReady,
+    fromClaudeProjectDir: root !== null,
     settled: false,
     timedOut: false
   };
+  if (root !== null) {
+    logger59.info("Resolved workspace root from CLAUDE_PROJECT_DIR", { workspaceRoot: root });
+    finishResolution(resolution);
+  }
 }
 function finishResolution(state) {
   if (state.timer !== void 0) clearTimeout(state.timer);
@@ -56140,6 +56185,10 @@ function applyWorkspaceRoots(roots, logger59) {
 async function resolveWorkspaceRootFromClient(server, logger59) {
   if (resolution === void 0) beginWorkspaceRootResolution(logger59);
   const state = resolution;
+  if (state?.fromClaudeProjectDir === true) return;
+  await requestWorkspaceRoots(server, logger59, state);
+}
+async function requestWorkspaceRoots(server, logger59, state) {
   try {
     if (server.server.getClientCapabilities()?.roots === void 0) {
       logger59.debug(
@@ -58957,4 +59006,4 @@ export {
   initializeSandbox,
   getSandboxMode
 };
-//# sourceMappingURL=chunk-45AUQYWF.js.map
+//# sourceMappingURL=chunk-UETCXCAS.js.map