agentic-qe 3.14.5 → 3.14.6

package/dist/mcp/handlers/core-handlers.js

@@ -115,14 +115,15 @@ export async function handleFleetInit(params) {
     try {
         // If already initialized, return existing fleet
         if (state.initialized && state.kernel && state.queen) {
+            const effectiveConfig = state.kernel.getConfig();
             return {
                 success: true,
                 data: {
                     fleetId: state.fleetId,
-                    topology: params.topology || 'hierarchical',
-                    maxAgents: params.maxAgents || 15,
-                    // Show only user-facing QE domains (12 domains, excludes internal 'coordination')
-                    enabledDomains: (params.enabledDomains || QE_USER_DOMAINS),
+                    topology: state.topology,
+                    maxAgents: effectiveConfig.maxConcurrentAgents,
+                    // Report the running kernel, not the later caller's requested domains.
+                    enabledDomains: effectiveConfig.enabledDomains.filter(d => d !== 'coordination'),
                     status: 'ready',
                 },
             };

package/dist/mcp/protocol-server.js

@@ -41,6 +41,7 @@ import { getLoadBalancer, } from './load-balancer.js';
 import { getPerformanceMonitor, } from './performance-monitor.js';
 // ADR-062: Loop detection for MCP tool calls
 import { ToolCallSignatureTracker } from '../kernel/anti-drift-middleware.js';
+import { formatErrorForLog } from '../logging/redaction.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
@@ -550,7 +551,7 @@ export class MCPProtocolServer {
         catch (err) {
             // Preserve the diagnostic for operators without exposing it in the MCP
             // response or AG-UI event. Stderr keeps stdio protocol output valid.
-            console.error(`[MCP] Tool ${name} failed:`, err);
+            console.error(`[MCP] Tool ${name} failed:`, formatErrorForLog(err));
             const error = err instanceof Error ? err : new Error('Tool execution failed');
             // IMP-08: Detect context overflow (413) and trigger reactive compaction
             const errorMsg = error.message || '';

package/dist/mcp/tools/base.d.ts

@@ -153,9 +153,11 @@ export interface MCPToolContext {
     kernel?: import('../../kernel/interfaces.js').QEKernel;
 }
 /**
- * Data source tracking for audit/transparency
+ * Data source tracking for audit/transparency.
+ * 'estimated': computed from real inputs mixed with assumed/default values
+ * (the result names which ones) — never presented as fully real (#535).
  */
-export type DataSource = 'real' | 'demo' | 'fallback';
+export type DataSource = 'real' | 'demo' | 'fallback' | 'estimated';
 /**
  * Logger interface for tool operations
  */
@@ -196,6 +198,11 @@ export declare abstract class MCPToolBase<TParams extends Record<string, unknown
      * MUST be called when returning sample data for transparency
      */
     protected markAsDemoData(context: MCPToolContext, reason: string): void;
+    /**
+     * Mark result as partly derived from assumed/default values (#535). The
+     * tool's result must say which values were assumed.
+     */
+    protected markAsEstimatedData(): void;
     /**
      * Mark result as coming from real service data
      */

package/dist/mcp/tools/base.js

@@ -277,6 +277,13 @@ export class MCPToolBase {
             demoMode: context.demoMode,
         });
     }
+    /**
+     * Mark result as partly derived from assumed/default values (#535). The
+     * tool's result must say which values were assumed.
+     */
+    markAsEstimatedData() {
+        this.currentDataSource = 'estimated';
+    }
     /**
      * Mark result as coming from real service data
      */

package/dist/mcp/tools/coherence/consensus.js

@@ -10,6 +10,32 @@
 import { MCPToolBase, } from '../base.js';
 import { createCoherenceService, wasmLoader, } from '../../../integrations/coherence/index.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { tallyVotes, describeBreakdown } from '../../../integrations/coherence/vote-tally.js';
+/**
+ * Check every vote's shape. Returns an error message naming the first bad
+ * field, or null when all votes are usable.
+ */
+function validateVotes(votes) {
+    const shape = 'Each vote must be { agentId: string, verdict: string | number | boolean, confidence: number 0-1 }.';
+    for (let i = 0; i < votes.length; i++) {
+        const vote = votes[i];
+        if (typeof vote !== 'object' || vote === null || Array.isArray(vote)) {
+            return `votes[${i}] must be an object. ${shape}`;
+        }
+        const { agentId, verdict, confidence } = vote;
+        if (typeof agentId !== 'string' || agentId.trim() === '') {
+            return `votes[${i}].agentId must be a non-empty string. ${shape}`;
+        }
+        const verdictType = typeof verdict;
+        if (verdictType !== 'string' && verdictType !== 'number' && verdictType !== 'boolean') {
+            return `votes[${i}].verdict is required (string, number, or boolean), got ${verdict === null ? 'null' : verdictType}. ${shape}`;
+        }
+        if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+            return `votes[${i}].confidence must be a number between 0 and 1, got ${JSON.stringify(confidence) ?? 'undefined'}. ${shape}`;
+        }
+    }
+    return null;
+}
 // ============================================================================
 // Schema
 // ============================================================================
@@ -18,7 +44,22 @@ const COHERENCE_CONSENSUS_SCHEMA = {
     properties: {
         votes: {
             type: 'array',
-            description: 'Array of agent votes to verify for consensus',
+            description: 'Array of agent votes to verify for consensus (at least 2). Each vote is an object ' +
+                '{ agentId: string, verdict: string | number | boolean, confidence: number 0-1, ' +
+                'agentType?: string, reasoning?: string }.',
+            items: {
+                type: 'object',
+                description: 'One agent vote',
+                properties: {
+                    agentId: { type: 'string', description: 'Agent identifier', minLength: 1 },
+                    agentType: { type: 'string', description: 'Agent type (default: worker)' },
+                    // `verdict` may be a string, number, or boolean, which this schema
+                    // type cannot express; it is required below and checked in execute().
+                    confidence: { type: 'number', description: 'Confidence in the verdict', minimum: 0, maximum: 1 },
+                    reasoning: { type: 'string', description: 'Optional reasoning text' },
+                },
+                required: ['agentId', 'verdict', 'confidence'],
+            },
         },
         confidenceThreshold: {
             type: 'number',
@@ -102,6 +143,13 @@ export class CoherenceConsensusTool extends MCPToolBase {
                 error: 'At least two votes are required to verify consensus',
             };
         }
+        // A vote without a usable verdict would be grouped as the string
+        // "undefined"; three such votes looked like a unanimous false consensus
+        // even for a 2-1 split sent under another key (issue #535).
+        const voteError = validateVotes(votes);
+        if (voteError) {
+            return { success: false, error: voteError };
+        }
         try {
             // Get service
             const service = await this.getService();
@@ -152,7 +200,8 @@ export class CoherenceConsensusTool extends MCPToolBase {
                     success: true,
                     data: {
                         ...fallbackResult,
-                        recommendation: 'Running in fallback mode (simple analysis). ' +
+                        recommendation: `Running in fallback mode (simple analysis): ${describeBreakdown(tallyVotes(votes))} ` +
+                            `across ${votes.length} votes. ` +
                             'Install prime-radiant-advanced-wasm for spectral consensus analysis.',
                         usedFallback: true,
                         executionTimeMs: Date.now() - startTime,

package/dist/mcp/tools/planning/goap-plan.d.ts

@@ -9,19 +9,21 @@
  */
 import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base.js';
 import { ToolResult } from '../../types.js';
-import { V3WorldState } from '../../../planning/index.js';
+import { type WorldStatePatch, type WorldStateProvenance, type WorldStateSources } from './world-state.js';
 /**
  * Parameters for GOAP plan tool
  */
 export interface GOAPPlanParams {
     /** Goal name (named goal) or custom goal conditions object */
     goal: string | Record<string, unknown>;
-    /** Current world state (auto-detected if not provided) */
-    currentState?: V3WorldState;
+    /** Current world state (auto-detected if not provided; may be partial) */
+    currentState?: WorldStatePatch;
     /** Plan constraints */
     constraints?: {
         maxCost?: number;
         maxDurationMs?: number;
+        /** Maximum number of plan steps (positive integer) */
+        maxSteps?: number;
         requiredAgentTypes?: string[];
         excludedActions?: string[];
     };
@@ -46,6 +48,13 @@ export interface GOAPPlanResult {
     stepCount: number;
     reusedFrom?: string;
     similarityScore?: number;
+    /**
+     * Where each start-state field came from ('live' | 'measured' | 'caller' |
+     * 'default'). Issue #535: the plan is only as real as its start state.
+     */
+    stateProvenance: WorldStateProvenance;
+    /** Start-state fields that were DEFAULT_V3_WORLD_STATE assumptions. */
+    defaultedFields: string[];
 }
 /**
  * GOAP Plan MCP Tool
@@ -53,7 +62,10 @@ export interface GOAPPlanResult {
  * Finds optimal action sequences to achieve QE goals using A* search.
  */
 export declare class GOAPPlanTool extends MCPToolBase<GOAPPlanParams, GOAPPlanResult> {
+    private readonly worldStateSources;
     private planner;
+    /** World-state sources; injectable for tests (defaults read live state). */
+    constructor(worldStateSources?: WorldStateSources);
     readonly config: MCPToolConfig;
     private buildSchema;
     /**
@@ -67,11 +79,12 @@ export declare class GOAPPlanTool extends MCPToolBase<GOAPPlanParams, GOAPPlanRe
     /**
      * Execute the GOAP planning
      */
-    execute(params: GOAPPlanParams, context: MCPToolContext): Promise<ToolResult<GOAPPlanResult>>;
+    execute(params: GOAPPlanParams, _context: MCPToolContext): Promise<ToolResult<GOAPPlanResult>>;
     /**
-     * Detect current world state
-     * In a full implementation, this would integrate with actual QE metrics
+     * Validate `constraints` (issue #535): must be an object, only known keys,
+     * numeric limits must be numbers, maxSteps a positive integer, and the
+     * list constraints string arrays.
      */
-    private detectCurrentState;
+    private validateConstraints;
 }
 //# sourceMappingURL=goap-plan.d.ts.map

package/dist/mcp/tools/planning/goap-plan.js

@@ -9,7 +9,16 @@
  */
 import { MCPToolBase, } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
-import { getSharedGOAPPlanner, DEFAULT_V3_WORLD_STATE, } from '../../../planning/index.js';
+import { getSharedGOAPPlanner, validateMaxSteps, } from '../../../planning/index.js';
+import { detectWorldState, overlayCallerState, validateWorldStatePatch, defaultedFields, } from './world-state.js';
+/** Constraint keys goap_plan understands; anything else is rejected (#535). */
+const KNOWN_CONSTRAINT_KEYS = [
+    'maxCost',
+    'maxDurationMs',
+    'maxSteps',
+    'requiredAgentTypes',
+    'excludedActions',
+];
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -19,7 +28,13 @@ import { getSharedGOAPPlanner, DEFAULT_V3_WORLD_STATE, } from '../../../planning
  * Finds optimal action sequences to achieve QE goals using A* search.
  */
 export class GOAPPlanTool extends MCPToolBase {
+    worldStateSources;
     planner = null;
+    /** World-state sources; injectable for tests (defaults read live state). */
+    constructor(worldStateSources = {}) {
+        super();
+        this.worldStateSources = worldStateSources;
+    }
     config = {
         name: 'qe/planning/goap_plan',
         description: 'Find optimal action plan to achieve a QE goal using A* search. ' +
@@ -52,6 +67,11 @@ export class GOAPPlanTool extends MCPToolBase {
                             type: 'number',
                             description: 'Maximum total duration in milliseconds',
                         },
+                        maxSteps: {
+                            type: 'number',
+                            description: 'Maximum number of steps (actions) in the plan; positive integer',
+                            minimum: 1,
+                        },
                         requiredAgentTypes: {
                             type: 'array',
                             description: 'Only use actions that these agent types can execute',
@@ -87,12 +107,18 @@ export class GOAPPlanTool extends MCPToolBase {
     /**
      * Execute the GOAP planning
      */
-    async execute(params, context) {
+    async execute(params, _context) {
         try {
+            // Issue #535: nested constraint properties aren't covered by the base
+            // schema validation (and the MCP bridge only exposes top-level
+            // params), so validate them here instead of silently ignoring them.
+            const constraintError = this.validateConstraints(params.constraints);
+            if (constraintError) {
+                return { success: false, error: constraintError };
+            }
             const planner = await this.getPlanner();
             // Resolve goal to conditions
             let goalConditions;
-            let goalName;
             if (typeof params.goal === 'string') {
                 // Look up named goal
                 const namedGoals = await planner.getGoals();
@@ -105,20 +131,34 @@ export class GOAPPlanTool extends MCPToolBase {
                     };
                 }
                 goalConditions = found.conditions;
-                goalName = found.name;
             }
             else {
                 // Use custom goal conditions
                 goalConditions = params.goal;
-                goalName = 'custom';
             }
-            // Get current state or use default
-            const currentState = params.currentState || await this.detectCurrentState();
+            // Issue #535: start from the live/measured world state (not a static
+            // DEFAULT_V3_WORLD_STATE copy), overlaid with any caller-supplied
+            // fields, and keep track of which values are assumptions.
+            if (params.currentState !== undefined) {
+                const stateError = validateWorldStatePatch(params.currentState, [
+                    ...planner.getReferencedStateKeys(),
+                    ...Object.keys(goalConditions),
+                ]);
+                if (stateError) {
+                    return { success: false, error: `Invalid currentState: ${stateError}` };
+                }
+            }
+            const detected = params.currentState
+                ? overlayCallerState(await detectWorldState(this.worldStateSources), params.currentState)
+                : await detectWorldState(this.worldStateSources);
+            const currentState = detected.state;
+            const defaulted = defaultedFields(detected.provenance);
             // Build constraints
             const constraints = params.constraints
                 ? {
                     maxCost: params.constraints.maxCost,
                     maxDurationMs: params.constraints.maxDurationMs,
+                    maxSteps: params.constraints.maxSteps,
                     requiredAgentTypes: params.constraints.requiredAgentTypes,
                     excludedActions: params.constraints.excludedActions,
                 }
@@ -126,14 +166,23 @@ export class GOAPPlanTool extends MCPToolBase {
             // Find plan using A* search
             const plan = await planner.findPlan(currentState, goalConditions, constraints);
             if (!plan) {
+                const stepHint = constraints?.maxSteps !== undefined
+                    ? ` (maxSteps: ${constraints.maxSteps} — the goal may need more steps)`
+                    : '';
                 return {
                     success: false,
-                    error: 'No valid plan found for the given goal and constraints. ' +
+                    error: `No valid plan found for the given goal and constraints${stepHint}. ` +
                         'Try relaxing constraints or seeding more actions.',
                 };
             }
-            // Mark as real data
-            this.markAsRealData();
+            // The search is real; the start state is only 'real' if nothing in it
+            // was an assumed default.
+            if (defaulted.length === 0) {
+                this.markAsRealData();
+            }
+            else {
+                this.markAsEstimatedData();
+            }
             return {
                 success: true,
                 data: {
@@ -151,6 +200,8 @@ export class GOAPPlanTool extends MCPToolBase {
                     stepCount: plan.actions.length,
                     reusedFrom: plan.reusedFrom,
                     similarityScore: plan.similarityScore,
+                    stateProvenance: detected.provenance,
+                    defaultedFields: defaulted,
                 },
             };
         }
@@ -162,17 +213,38 @@ export class GOAPPlanTool extends MCPToolBase {
         }
     }
     /**
-     * Detect current world state
-     * In a full implementation, this would integrate with actual QE metrics
+     * Validate `constraints` (issue #535): must be an object, only known keys,
+     * numeric limits must be numbers, maxSteps a positive integer, and the
+     * list constraints string arrays.
      */
-    async detectCurrentState() {
-        // Return default state for now
-        // Real implementation would query:
-        // - Coverage metrics from coverage-analysis domain
-        // - Test results from test-execution domain
-        // - Security scores from security-compliance domain
-        // - Fleet status from coordination
-        return { ...DEFAULT_V3_WORLD_STATE };
+    validateConstraints(constraints) {
+        if (constraints === undefined || constraints === null)
+            return null;
+        if (typeof constraints !== 'object' || Array.isArray(constraints)) {
+            return 'constraints must be an object';
+        }
+        const c = constraints;
+        const unknownKeys = Object.keys(c).filter((k) => !KNOWN_CONSTRAINT_KEYS.includes(k));
+        if (unknownKeys.length > 0) {
+            return (`Unknown constraint(s): ${unknownKeys.join(', ')}. ` +
+                `Supported constraints: ${KNOWN_CONSTRAINT_KEYS.join(', ')}`);
+        }
+        for (const key of ['maxCost', 'maxDurationMs']) {
+            const v = c[key];
+            if (v !== undefined && (typeof v !== 'number' || !Number.isFinite(v) || v < 0)) {
+                return `constraints.${key} must be a non-negative number, got ${String(v)}`;
+            }
+        }
+        const stepsError = validateMaxSteps(c.maxSteps);
+        if (stepsError)
+            return stepsError;
+        for (const key of ['requiredAgentTypes', 'excludedActions']) {
+            const v = c[key];
+            if (v !== undefined && (!Array.isArray(v) || !v.every((x) => typeof x === 'string'))) {
+                return `constraints.${key} must be an array of strings`;
+            }
+        }
+        return null;
     }
 }
 //# sourceMappingURL=goap-plan.js.map

package/dist/mcp/tools/planning/goap-status.d.ts

@@ -9,6 +9,7 @@
  */
 import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base.js';
 import { ToolResult } from '../../types.js';
+import { type WorldStateProvenance, type WorldStateSources } from './world-state.js';
 /**
  * Status type to query
  */
@@ -29,28 +30,44 @@ export interface GOAPStatusParams {
     [key: string]: unknown;
 }
 /**
- * World state status result
+ * World state status result.
+ *
+ * Issue #535: values that are not observed from a live source are reported
+ * as `null` (not the planner's optimistic defaults such as securityScore
+ * 100), and `provenance` names the source of every field.
  */
 export interface WorldStateResult {
     coverage: {
-        line: number;
-        branch: number;
-        function: number;
+        line: number | null;
+        branch: number | null;
+        function: number | null;
         measured: boolean;
+        /** Coverage report the values were read from, when measured. */
+        report?: {
+            source: string;
+            measuredAt: string;
+        };
     };
     quality: {
-        testsPassing: number;
-        securityScore: number;
-        performanceScore: number;
+        testsPassing: number | null;
+        securityScore: number | null;
+        performanceScore: number | null;
     };
     fleet: {
+        /** Whether a fleet (fleet_init) is running in this MCP server process. */
+        initialized: boolean;
         activeAgents: number;
-        maxAgents: number;
+        maxAgents: number | null;
+        availableAgents: string[];
     };
     resources: {
-        timeRemaining: number;
-        parallelSlots: number;
+        timeRemaining: number | null;
+        parallelSlots: number | null;
     };
+    /** Dotted field path -> 'live' | 'measured' | 'caller' | 'default'. */
+    provenance: WorldStateProvenance;
+    /** Fields the planner would fill with DEFAULT_V3_WORLD_STATE assumptions. */
+    defaultedFields: string[];
 }
 /**
  * Goals status result
@@ -132,8 +149,11 @@ export type GOAPStatusResult = {
  * Query GOAP system status for world state, goals, actions, or plans.
  */
 export declare class GOAPStatusTool extends MCPToolBase<GOAPStatusParams, GOAPStatusResult> {
+    private readonly worldStateSources;
     private planner;
     private executor;
+    /** World-state sources; injectable for tests (defaults read live state). */
+    constructor(worldStateSources?: WorldStateSources);
     readonly config: MCPToolConfig;
     private buildSchema;
     /**
@@ -151,9 +171,14 @@ export declare class GOAPStatusTool extends MCPToolBase<GOAPStatusParams, GOAPSt
     /**
      * Execute the status query
      */
-    execute(params: GOAPStatusParams, context: MCPToolContext): Promise<ToolResult<GOAPStatusResult>>;
+    execute(params: GOAPStatusParams, _context: MCPToolContext): Promise<ToolResult<GOAPStatusResult>>;
     /**
-     * Get current world state
+     * Get current world state.
+     *
+     * Issue #535: previously returned a static DEFAULT_V3_WORLD_STATE copy
+     * (fleet.activeAgents always 0) and called markAsRealData() on it. Now
+     * reads the live fleet and any coverage report, reports unobserved values
+     * as null, and only claims 'real' when nothing was defaulted.
      */
     private getWorldState;
     /**

package/dist/mcp/tools/planning/goap-status.js

@@ -9,7 +9,8 @@
  */
 import { MCPToolBase, } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
-import { getSharedGOAPPlanner, createMockExecutor, DEFAULT_V3_WORLD_STATE, getAllQEActions, } from '../../../planning/index.js';
+import { getSharedGOAPPlanner, createMockExecutor, getAllQEActions, } from '../../../planning/index.js';
+import { detectWorldState, defaultedFields, } from './world-state.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -19,8 +20,14 @@ import { getSharedGOAPPlanner, createMockExecutor, DEFAULT_V3_WORLD_STATE, getAl
  * Query GOAP system status for world state, goals, actions, or plans.
  */
 export class GOAPStatusTool extends MCPToolBase {
+    worldStateSources;
     planner = null;
     executor = null;
+    /** World-state sources; injectable for tests (defaults read live state). */
+    constructor(worldStateSources = {}) {
+        super();
+        this.worldStateSources = worldStateSources;
+    }
     config = {
         name: 'qe/planning/goap_status',
         description: 'Get GOAP system status: world state, available goals, actions, or plans. ' +
@@ -93,7 +100,7 @@ export class GOAPStatusTool extends MCPToolBase {
     /**
      * Execute the status query
      */
-    async execute(params, context) {
+    async execute(params, _context) {
         try {
             switch (params.type) {
                 case 'world':
@@ -121,37 +128,60 @@ export class GOAPStatusTool extends MCPToolBase {
         }
     }
     /**
-     * Get current world state
+     * Get current world state.
+     *
+     * Issue #535: previously returned a static DEFAULT_V3_WORLD_STATE copy
+     * (fleet.activeAgents always 0) and called markAsRealData() on it. Now
+     * reads the live fleet and any coverage report, reports unobserved values
+     * as null, and only claims 'real' when nothing was defaulted.
      */
     async getWorldState() {
-        // In a full implementation, this would query actual metrics
-        // For now, return the default state with some variation
-        const state = { ...DEFAULT_V3_WORLD_STATE };
-        this.markAsRealData();
+        const detected = await detectWorldState(this.worldStateSources);
+        const { state, provenance } = detected;
+        const observed = (field) => provenance[field] !== 'default';
+        const valueIfObserved = (field, value) => observed(field) ? value : null;
+        const defaulted = defaultedFields(provenance);
+        const exposedFields = [
+            'coverage.line', 'coverage.branch', 'coverage.function',
+            'quality.testsPassing', 'quality.securityScore', 'quality.performanceScore',
+            'fleet.activeAgents', 'fleet.maxAgents',
+            'resources.timeRemaining', 'resources.parallelSlots',
+        ];
+        if (exposedFields.every(observed)) {
+            this.markAsRealData();
+        }
+        else {
+            this.markAsEstimatedData();
+        }
         return {
             success: true,
             data: {
                 type: 'world',
                 data: {
                     coverage: {
-                        line: state.coverage.line,
-                        branch: state.coverage.branch,
-                        function: state.coverage.function,
+                        line: valueIfObserved('coverage.line', state.coverage.line),
+                        branch: valueIfObserved('coverage.branch', state.coverage.branch),
+                        function: valueIfObserved('coverage.function', state.coverage.function),
                         measured: state.coverage.measured,
+                        ...(detected.coverageReport ? { report: detected.coverageReport } : {}),
                     },
                     quality: {
-                        testsPassing: state.quality.testsPassing,
-                        securityScore: state.quality.securityScore,
-                        performanceScore: state.quality.performanceScore,
+                        testsPassing: valueIfObserved('quality.testsPassing', state.quality.testsPassing),
+                        securityScore: valueIfObserved('quality.securityScore', state.quality.securityScore),
+                        performanceScore: valueIfObserved('quality.performanceScore', state.quality.performanceScore),
                     },
                     fleet: {
+                        initialized: detected.fleetInitialized,
                         activeAgents: state.fleet.activeAgents,
-                        maxAgents: state.fleet.maxAgents,
+                        maxAgents: valueIfObserved('fleet.maxAgents', state.fleet.maxAgents),
+                        availableAgents: [...state.fleet.availableAgents],
                     },
                     resources: {
-                        timeRemaining: state.resources.timeRemaining,
-                        parallelSlots: state.resources.parallelSlots,
+                        timeRemaining: valueIfObserved('resources.timeRemaining', state.resources.timeRemaining),
+                        parallelSlots: valueIfObserved('resources.parallelSlots', state.resources.parallelSlots),
                     },
+                    provenance,
+                    defaultedFields: defaulted,
                 },
             },
         };
@@ -184,7 +214,6 @@ export class GOAPStatusTool extends MCPToolBase {
      * Get available actions
      */
     async getActions(category, limit = 50) {
-        const planner = await this.getPlanner();
         // Get actions from the library
         let actions = [];
         // Get actions from the action library
@@ -224,18 +253,18 @@ export class GOAPStatusTool extends MCPToolBase {
      */
     async getPlans(status, limit = 20) {
         const planner = await this.getPlanner();
-        // Get plan reuse statistics
-        const reuseStats = await planner.getPlanReuseStats();
-        // Plans are typically stored in the database
-        // For now, return empty list with stats
+        const [{ plans, count }, reuseStats] = await Promise.all([
+            planner.listPlanSummaries(status, limit),
+            planner.getPlanReuseStats(),
+        ]);
         this.markAsRealData();
         return {
             success: true,
             data: {
                 type: 'plans',
                 data: {
-                    plans: [], // Would query from database
-                    count: 0,
+                    plans,
+                    count,
                     reuseStats: {
                         totalPlans: reuseStats.totalPlans,
                         reusedPlans: reuseStats.reusedPlans,