claude-flow 3.63.6 → 3.63.7

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-tools.js

@@ -214,7 +214,7 @@ export const agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                agentType: { type: 'string', description: 'Type of agent to spawn' },
+                agentType: { type: 'string', description: 'Type of agent to spawn (a legacy `type` key is accepted as an alias)' },
                 agentId: { type: 'string', description: 'Optional custom agent ID' },
                 name: { type: 'string', description: 'Optional display name for the agent (shown by agent_list, agent_status and ruflo-console)' },
                 // #2085 — accept swarmId so spawned agents register in the
@@ -234,7 +234,19 @@ export const agentTools = [
             },
             required: ['agentType'],
         },
-        handler: async (input) => {
+        handler: async (rawInput) => {
+            // #4542: agent and command docs that `init` installed before 3.63.7 call
+            // agent_spawn with `type`. Accept it as an alias for `agentType`, and
+            // name the missing key ourselves: validateAgentSpawn maps agentType onto
+            // the security schema's `type` field and would report "type: Required".
+            let input = rawInput;
+            if (input.agentType === undefined && typeof input.type === 'string') {
+                const { type, ...rest } = input;
+                input = { ...rest, agentType: type };
+            }
+            if (typeof input.agentType !== 'string' || input.agentType === '') {
+                return { success: false, error: 'Input validation failed: agentType is required and must be a non-empty string (for example agentType: "coder")' };
+            }
             // Validate user-provided input (#1425: wire security validators to runtime)
             const validation = await validateAgentSpawn(input);
             if (!validation.valid) {
@@ -606,7 +618,7 @@ export const agentTools = [
             type: 'object',
             properties: {
                 action: { type: 'string', enum: ['status', 'scale', 'drain', 'fill'], description: 'Pool action' },
-                targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
+                targetSize: { type: 'number', description: 'Target pool size (scale: grow or shrink to it; fill: grow to it, never shrink)' },
                 agentType: { type: 'string', description: 'Agent type filter' },
             },
             required: ['action'],
@@ -653,7 +665,9 @@ export const agentTools = [
                     avgHealth: agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 0,
                 };
             }
-            if (action === 'scale') {
+            // #4555: fill was advertised in the enum but had no branch. It is scale
+            // without the shrink step: grow agentType's pool to targetSize, never terminate.
+            if (action === 'scale' || action === 'fill') {
                 const targetSize = input.targetSize === undefined ? 5 : input.targetSize;
                 if (typeof targetSize !== 'number' || !Number.isSafeInteger(targetSize) || targetSize < 0) {
                     return { action, error: 'targetSize must be a non-negative safe integer' };
@@ -678,7 +692,7 @@ export const agentTools = [
                         added.push(agentId);
                     }
                 }
-                else if (delta < 0) {
+                else if (delta < 0 && action === 'scale') {
                     const toRemove = agents.filter(a => a.agentType === agentType && a.status === 'idle').slice(0, -delta);
                     for (const agent of toRemove) {
                         store.agents[agent.agentId].status = 'terminated';

package/v3/@claude-flow/cli/dist/src/mcp-tools/coordination-tools.js

@@ -225,8 +225,8 @@ export const coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', enum: ['status', 'trigger', 'resolve'], description: 'Action to perform' },
-                force: { type: 'boolean', description: 'Force synchronization' },
+                action: { type: 'string', enum: ['status', 'trigger', 'resolve'], description: 'Action to perform. `trigger` is unavailable: nodes are local records with no sync backend, so it is refused (#4557)' },
+                force: { type: 'boolean', description: 'Unused: `trigger` is refused regardless (#4557)' },
                 conflictResolution: { type: 'string', enum: ['latest', 'merge', 'manual'], description: 'Conflict resolution strategy' },
             },
         },
@@ -243,18 +243,16 @@ export const coordinationTools = [
                 };
             }
             if (action === 'trigger') {
-                store.sync.syncCount++;
-                store.sync.lastSync = new Date().toISOString();
-                store.sync.pendingChanges = 0;
-                // Simulate sync
-                await new Promise(resolve => setTimeout(resolve, 50));
-                saveCoordStore(store);
+                // #4557: this waited on a simulated 50ms "sync", bumped syncCount/lastSync
+                // and reported every node synchronized, but no state moves between
+                // nodes. Refuse without touching the stored sync record, as
+                // neural_compress quantize/prune do (#4195, #4423).
                 return {
-                    success: true,
-                    action: 'synchronized',
+                    success: false,
+                    action: 'trigger',
+                    error: 'Synchronization is unavailable: coordination nodes are local records with no sync backend, so nothing would be transferred.',
                     syncCount: store.sync.syncCount,
-                    syncedAt: store.sync.lastSync,
-                    nodesSync: Object.keys(store.nodes).length,
+                    lastSync: store.sync.lastSync,
                 };
             }
             if (action === 'resolve') {

package/v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -2212,7 +2212,14 @@ export const hooksBuildAgents = {
         },
     },
     handler: async (params) => {
-        const outputDir = resolve(params.outputDir || './agents');
+        // #4558: outputDir was never validated and resolved against the process
+        // cwd, so a default call from another directory overwrote files there.
+        if (params.outputDir !== undefined) {
+            const v = validatePath(params.outputDir, 'outputDir');
+            if (!v.valid)
+                return { success: false, error: v.error };
+        }
+        const outputDir = resolve(getProjectCwd(), params.outputDir || './agents');
         const focus = params.focus || 'all';
         const format = params.format || 'yaml';
         const persist = params.persist !== false; // Default to true
@@ -2255,9 +2262,11 @@ export const hooksBuildAgents = {
             agents: filteredAgents,
             stats: {
                 configsGenerated: filteredAgents.length,
-                patternsApplied: filteredAgents.length * 3,
+                // #4558: was agents * 3; no pretrain data is read, the configs are templates.
+                patternsApplied: 0,
                 optimizationsIncluded: filteredAgents.reduce((acc, a) => acc + a.optimizations.length, 0),
             },
+            _note: 'Configs are built-in templates; pretrain data is not read.',
         };
     },
 };

package/v3/@claude-flow/cli/dist/src/mcp-tools/performance-tools.js

@@ -612,6 +612,14 @@ export const performanceTools = [
             };
             const cpuStats = calcStats(cpuHistory, cpuPercent);
             const memStats = calcStats(memHistory, memUsedMB);
+            // #4554: latency/throughput used to be fixed literals (45ms, 1250 ops/s).
+            // Report the samples performance_report records (ADR-093 F8), or say none exist.
+            const sampled = (values, unit) => {
+                const real = values.filter(n => Number.isFinite(n));
+                return real.length === 0
+                    ? { available: false, unit, samples: 0, _real: false, _note: 'No samples recorded yet: run performance_report to record one.' }
+                    : { ...calcStats(real, real[real.length - 1]), unit, samples: real.length, _real: true };
+            };
             const allMetrics = {
                 cpu: {
                     ...cpuStats,
@@ -630,30 +638,12 @@ export const performanceTools = [
                     unit: 'MB',
                     _real: true,
                 },
-                latency: {
-                    current: 45,
-                    avg: 52,
-                    min: 15,
-                    max: 250,
-                    p50: 48,
-                    p95: 150,
-                    p99: 220,
-                    unit: 'ms',
-                },
-                throughput: {
-                    current: 1250,
-                    avg: 1100,
-                    min: 500,
-                    max: 2000,
-                    p50: 1050,
-                    p95: 1800,
-                    p99: 1950,
-                    unit: 'ops/s',
-                },
+                latency: sampled(history.map(m => m.latency?.avg), 'ms'),
+                throughput: sampled(history.map(m => m.throughput?.operations), 'ops/s'),
             };
             if (metric === 'all') {
                 return {
-                    _real: true,
+                    _real: Object.values(allMetrics).every(m => m._real),
                     metrics: allMetrics,
                     aggregation,
                     historySize: history.length,
@@ -662,9 +652,9 @@ export const performanceTools = [
             }
             const selectedMetric = allMetrics[metric];
             return {
-                _real: ['cpu', 'memory'].includes(metric),
+                _real: selectedMetric._real,
                 metric,
-                value: selectedMetric[aggregation],
+                value: selectedMetric[aggregation] ?? null,
                 unit: selectedMetric.unit,
                 details: selectedMetric,
                 timestamp: new Date().toISOString(),

package/v3/@claude-flow/cli/dist/src/mcp-tools/session-tools.js

@@ -54,6 +54,21 @@ function ensureSessionDir() {
         mkdirRestricted(dir);
     }
 }
+/**
+ * The session hook (`session.js` from init/helpers-generator.ts) writes its
+ * records into this same directory: `current.json` and `session-<n>.json`
+ * archives shaped `{ id, startedAt, ... }` rather than session_save's
+ * `{ sessionId, name, savedAt, stats }`. Read the id and time from either shape
+ * (ADR-093 F6), falling back to the file's own id.
+ */
+function sessionIdentity(session, fileId) {
+    const raw = session;
+    const pick = (...values) => values.find((v) => typeof v === 'string' && v !== '');
+    return {
+        sessionId: pick(raw.sessionId, raw.id) ?? fileId,
+        savedAt: pick(raw.savedAt, raw.startedAt) ?? '',
+    };
+}
 function loadSession(sessionId) {
     try {
         const path = getSessionPath(sessionId);
@@ -583,12 +598,13 @@ export const sessionTools = [
             if (session) {
                 const path = getSessionPath(sessionId);
                 const stat = statSync(path);
+                const identity = sessionIdentity(session, sessionId);
                 return {
-                    sessionId: session.sessionId,
-                    name: session.name,
+                    sessionId: identity.sessionId,
+                    name: session.name ?? identity.sessionId,
                     description: session.description,
-                    savedAt: session.savedAt,
-                    stats: session.stats,
+                    savedAt: identity.savedAt,
+                    stats: session.stats ?? null,
                     fileSize: stat.size,
                     path,
                     hasData: {
@@ -631,12 +647,13 @@ export const sessionTools = [
             const session = loadSession(sessionId);
             if (!session)
                 return { sessionId, status: 'unknown', startedAt: '', error: 'Session file unreadable' };
+            const identity = sessionIdentity(session, sessionId);
             return {
-                sessionId: session.sessionId,
-                name: session.name,
+                sessionId: identity.sessionId,
+                name: session.name ?? identity.sessionId,
                 status: 'active',
-                startedAt: session.savedAt,
-                stats: session.stats,
+                startedAt: identity.savedAt,
+                stats: session.stats ?? null,
             };
         },
     },

package/v3/@claude-flow/cli/dist/src/missions/schemas.d.ts

@@ -73,8 +73,7 @@ export declare const missionRecordSchema: z.ZodObject<{
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    createdAt: string;
-    updatedAt: string;
+    state: "draft" | "planned" | "awaitingAuthorization" | "queued" | "running" | "pauseRequested" | "paused" | "blocked" | "verifying" | "completed" | "failed" | "cancelRequested" | "cancelled";
     objective: string;
     schemaVersion: 1;
     missionId: string;
@@ -90,17 +89,17 @@ export declare const missionRecordSchema: z.ZodObject<{
     policyRef: string;
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
-    state: "completed" | "running" | "failed" | "queued" | "cancelled" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "paused" | "blocked" | "verifying" | "cancelRequested";
     evidenceRefs: string[];
     acceptance: {
         revision: number;
         criteriaDigest: string;
     };
     lastEventSequence: number;
-    authorizationRef?: string | undefined;
-}, {
     createdAt: string;
     updatedAt: string;
+    authorizationRef?: string | undefined;
+}, {
+    state: "draft" | "planned" | "awaitingAuthorization" | "queued" | "running" | "pauseRequested" | "paused" | "blocked" | "verifying" | "completed" | "failed" | "cancelRequested" | "cancelled";
     objective: string;
     schemaVersion: 1;
     missionId: string;
@@ -116,13 +115,14 @@ export declare const missionRecordSchema: z.ZodObject<{
     policyRef: string;
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
-    state: "completed" | "running" | "failed" | "queued" | "cancelled" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "paused" | "blocked" | "verifying" | "cancelRequested";
     evidenceRefs: string[];
     acceptance: {
         revision: number;
         criteriaDigest: string;
     };
     lastEventSequence: number;
+    createdAt: string;
+    updatedAt: string;
     authorizationRef?: string | undefined;
 }>;
 export type MissionRecord = z.infer<typeof missionRecordSchema>;
@@ -145,8 +145,8 @@ export declare const taskSpecSchema: z.ZodObject<{
     checkpoint: z.ZodOptional<z.ZodString>;
     acceptanceEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
-    title: string;
     id: string;
+    title: string;
     dependsOn: string[];
     executor: {
         mode: "durable-executor" | "session-bound";
@@ -157,8 +157,8 @@ export declare const taskSpecSchema: z.ZodObject<{
     acceptanceEvidence: string[];
     checkpoint?: string | undefined;
 }, {
-    title: string;
     id: string;
+    title: string;
     executor: {
         mode: "durable-executor" | "session-bound";
         requirement: string;
@@ -185,15 +185,15 @@ export declare const acceptanceCriterionSchema: z.ZodObject<{
     producer: string;
     independent: boolean;
     mandatory: boolean;
-    threshold?: string | undefined;
     baseline?: string | undefined;
+    threshold?: string | undefined;
 }, {
     id: string;
     check: string;
     producer: string;
-    threshold?: string | undefined;
     inputs?: string[] | undefined;
     baseline?: string | undefined;
+    threshold?: string | undefined;
     independent?: boolean | undefined;
     mandatory?: boolean | undefined;
 }>;
@@ -208,15 +208,15 @@ export declare const budgetSpecSchema: z.ZodObject<{
     currency: string;
     ceilingMinor: number;
     tokens?: number | undefined;
-    wallTimeSeconds?: number | undefined;
     concurrency?: number | undefined;
+    wallTimeSeconds?: number | undefined;
     retries?: number | undefined;
 }, {
     currency: string;
     ceilingMinor: number;
     tokens?: number | undefined;
-    wallTimeSeconds?: number | undefined;
     concurrency?: number | undefined;
+    wallTimeSeconds?: number | undefined;
     retries?: number | undefined;
 }>;
 export declare const planBodySchema: z.ZodObject<{
@@ -239,8 +239,8 @@ export declare const planBodySchema: z.ZodObject<{
         checkpoint: z.ZodOptional<z.ZodString>;
         acceptanceEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     }, "strict", z.ZodTypeAny, {
-        title: string;
         id: string;
+        title: string;
         dependsOn: string[];
         executor: {
             mode: "durable-executor" | "session-bound";
@@ -251,8 +251,8 @@ export declare const planBodySchema: z.ZodObject<{
         acceptanceEvidence: string[];
         checkpoint?: string | undefined;
     }, {
-        title: string;
         id: string;
+        title: string;
         executor: {
             mode: "durable-executor" | "session-bound";
             requirement: string;
@@ -279,15 +279,15 @@ export declare const planBodySchema: z.ZodObject<{
         producer: string;
         independent: boolean;
         mandatory: boolean;
-        threshold?: string | undefined;
         baseline?: string | undefined;
+        threshold?: string | undefined;
     }, {
         id: string;
         check: string;
         producer: string;
-        threshold?: string | undefined;
         inputs?: string[] | undefined;
         baseline?: string | undefined;
+        threshold?: string | undefined;
         independent?: boolean | undefined;
         mandatory?: boolean | undefined;
     }>, "many">;
@@ -302,15 +302,15 @@ export declare const planBodySchema: z.ZodObject<{
         currency: string;
         ceilingMinor: number;
         tokens?: number | undefined;
-        wallTimeSeconds?: number | undefined;
         concurrency?: number | undefined;
+        wallTimeSeconds?: number | undefined;
         retries?: number | undefined;
     }, {
         currency: string;
         ceilingMinor: number;
         tokens?: number | undefined;
-        wallTimeSeconds?: number | undefined;
         concurrency?: number | undefined;
+        wallTimeSeconds?: number | undefined;
         retries?: number | undefined;
     }>;
     scope: z.ZodDefault<z.ZodObject<{
@@ -322,8 +322,8 @@ export declare const planBodySchema: z.ZodObject<{
     }>>;
 }, "strict", z.ZodTypeAny, {
     tasks: {
-        title: string;
         id: string;
+        title: string;
         dependsOn: string[];
         executor: {
             mode: "durable-executor" | "session-bound";
@@ -341,15 +341,15 @@ export declare const planBodySchema: z.ZodObject<{
         producer: string;
         independent: boolean;
         mandatory: boolean;
-        threshold?: string | undefined;
         baseline?: string | undefined;
+        threshold?: string | undefined;
     }[];
     budget: {
         currency: string;
         ceilingMinor: number;
         tokens?: number | undefined;
-        wallTimeSeconds?: number | undefined;
         concurrency?: number | undefined;
+        wallTimeSeconds?: number | undefined;
         retries?: number | undefined;
     };
     scope: {
@@ -357,8 +357,8 @@ export declare const planBodySchema: z.ZodObject<{
     };
 }, {
     tasks: {
-        title: string;
         id: string;
+        title: string;
         executor: {
             mode: "durable-executor" | "session-bound";
             requirement: string;
@@ -373,9 +373,9 @@ export declare const planBodySchema: z.ZodObject<{
         id: string;
         check: string;
         producer: string;
-        threshold?: string | undefined;
         inputs?: string[] | undefined;
         baseline?: string | undefined;
+        threshold?: string | undefined;
         independent?: boolean | undefined;
         mandatory?: boolean | undefined;
     }[];
@@ -383,8 +383,8 @@ export declare const planBodySchema: z.ZodObject<{
         currency: string;
         ceilingMinor: number;
         tokens?: number | undefined;
-        wallTimeSeconds?: number | undefined;
         concurrency?: number | undefined;
+        wallTimeSeconds?: number | undefined;
         retries?: number | undefined;
     };
     scope?: {
@@ -427,8 +427,8 @@ export declare const planInputSchema: z.ZodObject<{
             checkpoint: z.ZodOptional<z.ZodString>;
             acceptanceEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         }, "strict", z.ZodTypeAny, {
-            title: string;
             id: string;
+            title: string;
             dependsOn: string[];
             executor: {
                 mode: "durable-executor" | "session-bound";
@@ -439,8 +439,8 @@ export declare const planInputSchema: z.ZodObject<{
             acceptanceEvidence: string[];
             checkpoint?: string | undefined;
         }, {
-            title: string;
             id: string;
+            title: string;
             executor: {
                 mode: "durable-executor" | "session-bound";
                 requirement: string;
@@ -467,15 +467,15 @@ export declare const planInputSchema: z.ZodObject<{
             producer: string;
             independent: boolean;
             mandatory: boolean;
-            threshold?: string | undefined;
             baseline?: string | undefined;
+            threshold?: string | undefined;
         }, {
             id: string;
             check: string;
             producer: string;
-            threshold?: string | undefined;
             inputs?: string[] | undefined;
             baseline?: string | undefined;
+            threshold?: string | undefined;
             independent?: boolean | undefined;
             mandatory?: boolean | undefined;
         }>, "many">;
@@ -490,15 +490,15 @@ export declare const planInputSchema: z.ZodObject<{
             currency: string;
             ceilingMinor: number;
             tokens?: number | undefined;
-            wallTimeSeconds?: number | undefined;
             concurrency?: number | undefined;
+            wallTimeSeconds?: number | undefined;
             retries?: number | undefined;
         }, {
             currency: string;
             ceilingMinor: number;
             tokens?: number | undefined;
-            wallTimeSeconds?: number | undefined;
             concurrency?: number | undefined;
+            wallTimeSeconds?: number | undefined;
             retries?: number | undefined;
         }>;
         scope: z.ZodDefault<z.ZodObject<{
@@ -510,8 +510,8 @@ export declare const planInputSchema: z.ZodObject<{
         }>>;
     }, "strict", z.ZodTypeAny, {
         tasks: {
-            title: string;
             id: string;
+            title: string;
             dependsOn: string[];
             executor: {
                 mode: "durable-executor" | "session-bound";
@@ -529,15 +529,15 @@ export declare const planInputSchema: z.ZodObject<{
             producer: string;
             independent: boolean;
             mandatory: boolean;
-            threshold?: string | undefined;
             baseline?: string | undefined;
+            threshold?: string | undefined;
         }[];
         budget: {
             currency: string;
             ceilingMinor: number;
             tokens?: number | undefined;
-            wallTimeSeconds?: number | undefined;
             concurrency?: number | undefined;
+            wallTimeSeconds?: number | undefined;
             retries?: number | undefined;
         };
         scope: {
@@ -545,8 +545,8 @@ export declare const planInputSchema: z.ZodObject<{
         };
     }, {
         tasks: {
-            title: string;
             id: string;
+            title: string;
             executor: {
                 mode: "durable-executor" | "session-bound";
                 requirement: string;
@@ -561,9 +561,9 @@ export declare const planInputSchema: z.ZodObject<{
             id: string;
             check: string;
             producer: string;
-            threshold?: string | undefined;
             inputs?: string[] | undefined;
             baseline?: string | undefined;
+            threshold?: string | undefined;
             independent?: boolean | undefined;
             mandatory?: boolean | undefined;
         }[];
@@ -571,8 +571,8 @@ export declare const planInputSchema: z.ZodObject<{
             currency: string;
             ceilingMinor: number;
             tokens?: number | undefined;
-            wallTimeSeconds?: number | undefined;
             concurrency?: number | undefined;
+            wallTimeSeconds?: number | undefined;
             retries?: number | undefined;
         };
         scope?: {
@@ -584,8 +584,8 @@ export declare const planInputSchema: z.ZodObject<{
     missionId: string;
     plan: {
         tasks: {
-            title: string;
             id: string;
+            title: string;
             dependsOn: string[];
             executor: {
                 mode: "durable-executor" | "session-bound";
@@ -603,15 +603,15 @@ export declare const planInputSchema: z.ZodObject<{
             producer: string;
             independent: boolean;
             mandatory: boolean;
-            threshold?: string | undefined;
             baseline?: string | undefined;
+            threshold?: string | undefined;
         }[];
         budget: {
             currency: string;
             ceilingMinor: number;
             tokens?: number | undefined;
-            wallTimeSeconds?: number | undefined;
             concurrency?: number | undefined;
+            wallTimeSeconds?: number | undefined;
             retries?: number | undefined;
         };
         scope: {
@@ -624,8 +624,8 @@ export declare const planInputSchema: z.ZodObject<{
     missionId: string;
     plan: {
         tasks: {
-            title: string;
             id: string;
+            title: string;
             executor: {
                 mode: "durable-executor" | "session-bound";
                 requirement: string;
@@ -640,9 +640,9 @@ export declare const planInputSchema: z.ZodObject<{
             id: string;
             check: string;
             producer: string;
-            threshold?: string | undefined;
             inputs?: string[] | undefined;
             baseline?: string | undefined;
+            threshold?: string | undefined;
             independent?: boolean | undefined;
             mandatory?: boolean | undefined;
         }[];
@@ -650,8 +650,8 @@ export declare const planInputSchema: z.ZodObject<{
             currency: string;
             ceilingMinor: number;
             tokens?: number | undefined;
-            wallTimeSeconds?: number | undefined;
             concurrency?: number | undefined;
+            wallTimeSeconds?: number | undefined;
             retries?: number | undefined;
         };
         scope?: {
@@ -672,13 +672,13 @@ export declare const eventsInputSchema: z.ZodObject<{
     afterSequence: z.ZodDefault<z.ZodNumber>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    limit: number;
     missionId: string;
     afterSequence: number;
+    limit: number;
 }, {
     missionId: string;
-    limit?: number | undefined;
     afterSequence?: number | undefined;
+    limit?: number | undefined;
 }>;
 export declare const requestActionInputSchema: z.ZodObject<{
     requestId: z.ZodString;
@@ -687,16 +687,16 @@ export declare const requestActionInputSchema: z.ZodObject<{
     action: z.ZodEnum<["pause", "resume", "cancel", "requestAuthorization", "admit"]>;
     reason: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
     requestId: string;
     missionId: string;
     expectedRevision: number;
+    action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
     reason?: string | undefined;
 }, {
-    action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
     requestId: string;
     missionId: string;
     expectedRevision: number;
+    action: "pause" | "resume" | "cancel" | "requestAuthorization" | "admit";
     reason?: string | undefined;
 }>;
 export type CreateInput = z.infer<typeof createInputSchema>;