@claude-flow/cli 3.72.2 → 3.74.0

package/dist/src/metaharness/darwin-lib.js

@@ -0,0 +1,150 @@
+/**
+ * In-process access to @metaharness/darwin (ADR-526).
+ *
+ * darwin is a regular dependency of the CLI, so the long-lived MCP server can
+ * import it once and answer `metaharness_bench --op verify` and every
+ * `metaharness_gepa` op without spawning `node bench.mjs` → `node darwin/cli.js`
+ * per call. Each function returns the same {exitCode, json} pair the plugin
+ * script would have produced, so callers keep the existing
+ * {success, data, degraded, exitCode} contract.
+ *
+ * Graceful degradation (ADR-150 rule 3) still holds: if the import fails, every
+ * function returns null and the caller falls back to the subprocess path.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+// The specifiers are held in variables so a missing package degrades at
+// runtime instead of failing the CLI's own type-check or bundling.
+const ROOT_SPEC = '@metaharness/darwin';
+const GEPA_SPEC = '@metaharness/darwin/gepa';
+let rootPromise = null;
+let gepaPromise = null;
+export function loadDarwin() {
+    rootPromise ??= import(ROOT_SPEC).then((m) => m, () => null);
+    return rootPromise;
+}
+export function loadDarwinGepa() {
+    gepaPromise ??= import(GEPA_SPEC).then((m) => m, () => null);
+    return gepaPromise;
+}
+/** Test hook: forget the cached modules. */
+export function resetDarwinCache() {
+    rootPromise = null;
+    gepaPromise = null;
+}
+/**
+ * `bench verify <suite>` in-process. Mirrors plugins/ruflo-metaharness/scripts/bench.mjs:
+ * exit 2 + no payload for a missing path, exit 1 when the suite fails to load
+ * (darwin's loadSuite throws on tamper) or its hash does not match, exit 0 otherwise.
+ * Returns null when darwin cannot be imported.
+ */
+export async function benchVerify(suitePath) {
+    const darwin = await loadDarwin();
+    if (!darwin)
+        return null;
+    if (!suitePath || !existsSync(resolve(suitePath)))
+        return { exitCode: 2, json: null };
+    const start = Date.now();
+    const file = resolve(suitePath);
+    try {
+        const suite = await darwin.bench.loadSuite(file);
+        const check = darwin.bench.verifySuite(suite);
+        const tasks = Array.isArray(suite.tasks) ? suite.tasks.length : 0;
+        const data = {
+            op: 'verify',
+            suiteId: suite.id,
+            version: suite.version,
+            tasks,
+            hashOk: check.ok,
+            hash: check.actual,
+            // Same line the darwin CLI prints, so readers of the old shape keep working.
+            stdoutTail: `Suite ${suite.id}@${suite.version}: ${tasks} tasks, hash ${check.ok ? 'OK' : 'MISMATCH'} (${String(check.actual).slice(0, 12)}…)\n`,
+            durationMs: Date.now() - start,
+        };
+        return { exitCode: check.ok ? 0 : 1, json: { success: check.ok, data, generatedAt: new Date().toISOString() } };
+    }
+    catch (e) {
+        const data = { op: 'verify', error: e instanceof Error ? e.message : String(e), durationMs: Date.now() - start };
+        return { exitCode: 1, json: { success: false, data, generatedAt: new Date().toISOString() } };
+    }
+}
+const GEPA_OPS = ['genome', 'validate', 'render', 'analyze'];
+function readJson(path) {
+    try {
+        return { ok: true, value: JSON.parse(readFileSync(path, 'utf8')) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+/**
+ * GEPA genome ops in-process. Mirrors plugins/ruflo-metaharness/scripts/gepa.mjs,
+ * including its exit codes: 2 for input errors (no payload), 1 for an invalid
+ * genome with alertOnInvalid, 0 otherwise. Returns null when darwin/gepa cannot
+ * be imported.
+ */
+export async function gepaOp(input) {
+    if (!GEPA_OPS.includes(input.op))
+        return { exitCode: 2, json: null };
+    const gepa = await loadDarwinGepa();
+    if (!gepa)
+        return null;
+    const start = Date.now();
+    let out;
+    try {
+        const loadGenome = () => {
+            if (input.path) {
+                if (!existsSync(input.path))
+                    return null;
+                return { genome: gepa.loadGenome(readFileSync, input.path), source: input.path };
+            }
+            return { genome: gepa.loadCand6Genome(), source: gepa.CAND6_GENOME_PATH };
+        };
+        if (input.op === 'genome') {
+            const loaded = loadGenome();
+            if (!loaded)
+                return { exitCode: 2, json: null };
+            const errors = gepa.validateGenome(loaded.genome);
+            out = { op: 'genome', source: loaded.source, valid: errors.length === 0, errors, genome: loaded.genome };
+        }
+        else if (input.op === 'validate') {
+            let raw;
+            if (input.path) {
+                if (!existsSync(input.path))
+                    return { exitCode: 2, json: null };
+                const r = readJson(input.path);
+                if (!r.ok)
+                    return { exitCode: 2, json: null };
+                raw = r.value;
+            }
+            else {
+                raw = gepa.loadCand6Genome();
+            }
+            const errors = gepa.validateGenome(raw);
+            out = { op: 'validate', source: input.path ?? gepa.CAND6_GENOME_PATH, valid: errors.length === 0, errors };
+        }
+        else if (input.op === 'render') {
+            const loaded = loadGenome();
+            if (!loaded)
+                return { exitCode: 2, json: null };
+            const system = gepa.buildSystemFromGenome(loaded.genome, input.ext, input.glob);
+            out = { op: 'render', source: loaded.source, chars: system.length, system };
+        }
+        else {
+            if (!input.transcript || !existsSync(input.transcript))
+                return { exitCode: 2, json: null };
+            const r = readJson(input.transcript);
+            if (!r.ok || !Array.isArray(r.value))
+                return { exitCode: 2, json: null };
+            out = { op: 'analyze', source: input.transcript, entries: r.value.length, analysis: gepa.analyzeTranscript(r.value) };
+        }
+    }
+    catch {
+        // gepa.mjs exits 2 on any thrown error (its main().catch handler).
+        return { exitCode: 2, json: null };
+    }
+    out.durationMs = Date.now() - start;
+    const exitCode = input.alertOnInvalid && out.valid === false ? 1 : 0;
+    return { exitCode, json: out };
+}
+//# sourceMappingURL=darwin-lib.js.map

package/dist/src/transfer/store/download.d.ts

@@ -36,7 +36,7 @@ export declare class PatternDownloader {
      */
     private verifyChecksum;
     /**
-     * Verify content signature using crypto
+     * Verify an Ed25519 signature over the content. Any error is a failure.
      */
     private verifySignature;
     /**

package/dist/src/transfer/store/download.js

@@ -75,15 +75,20 @@ export class PatternDownloader {
                     console.log(`[Download] Checksum verified!`);
                 }
             }
-            // Verify signature if available
+            // Verify signature if available. A pattern that carries a signature
+            // which does not verify is refused rather than written.
             if (pattern.signature && pattern.publicKey) {
-                const sigVerified = this.verifySignature(content, pattern.signature, pattern.publicKey);
+                const sigVerified = await this.verifySignature(content, pattern.signature, pattern.publicKey);
                 if (!sigVerified) {
-                    console.warn(`[Download] Warning: Signature verification failed!`);
-                }
-                else {
-                    console.log(`[Download] Signature verified!`);
+                    console.warn(`[Download] Signature verification failed, not writing the pattern.`);
+                    return {
+                        success: false,
+                        pattern,
+                        verified: false,
+                        size: content.length,
+                    };
                 }
+                console.log(`[Download] Signature verified!`);
             }
             // Write to file
             fs.writeFileSync(outputPath, content);
@@ -228,28 +233,24 @@ export class PatternDownloader {
         return actualChecksum === expectedChecksum;
     }
     /**
-     * Verify content signature using crypto
+     * Verify an Ed25519 signature over the content. Any error is a failure.
      */
-    verifySignature(content, signature, publicKey) {
-        // Check signature format
+    async verifySignature(content, signature, publicKey) {
         if (!signature.startsWith('ed25519:') || !publicKey.startsWith('ed25519:')) {
             return false;
         }
         try {
-            // For HMAC-based signatures (used in publish.ts)
-            const sigHex = signature.replace('ed25519:', '');
-            const keyHex = publicKey.replace('ed25519:', '');
-            // Verify HMAC signature
-            const expectedSig = crypto
-                .createHmac('sha256', keyHex)
-                .update(content)
-                .digest('hex');
-            // Constant-time comparison to prevent timing attacks
-            return crypto.timingSafeEqual(Buffer.from(sigHex, 'hex'), Buffer.from(expectedSig, 'hex'));
+            const ed = await import('@noble/ed25519');
+            const sigBytes = Buffer.from(signature.slice('ed25519:'.length), 'hex');
+            const pubBytes = Buffer.from(publicKey.slice('ed25519:'.length), 'hex');
+            if (sigBytes.length !== 64 || pubBytes.length !== 32) {
+                return false;
+            }
+            // RFC 8032 strict mode, as in transfer/ipfs/client.ts.
+            return await ed.verifyAsync(sigBytes, content, pubBytes, { zip215: false });
         }
         catch {
-            // If crypto verification fails, check basic format
-            return signature.length > 20 && publicKey.length > 20;
+            return false;
         }
     }
     /**

package/dist/src/transfer/store/publish.d.ts

@@ -16,7 +16,7 @@ export declare class PatternPublisher {
      */
     publishPattern(cfp: CFPFormat, options: PublishOptions): Promise<PublishResult>;
     /**
-     * Sign content with private key
+     * Sign content with Ed25519. The private key file holds a 32-byte hex seed.
      */
     private signContent;
     /**

package/dist/src/transfer/store/publish.js

@@ -37,7 +37,7 @@ export class PatternPublisher {
             let signature;
             let publicKey;
             if (options.privateKeyPath && fs.existsSync(options.privateKeyPath)) {
-                const signResult = this.signContent(contentBuffer, options.privateKeyPath);
+                const signResult = await this.signContent(contentBuffer, options.privateKeyPath);
                 signature = signResult.signature;
                 publicKey = signResult.publicKey;
                 console.log(`[Publish] Content signed`);
@@ -148,21 +148,20 @@ export class PatternPublisher {
         }
     }
     /**
-     * Sign content with private key
+     * Sign content with Ed25519. The private key file holds a 32-byte hex seed.
      */
-    signContent(content, privateKeyPath) {
-        // In production: Use actual Ed25519 signing
-        // For demo: Generate mock signature
-        const privateKey = fs.readFileSync(privateKeyPath, 'utf-8').trim();
-        const signature = crypto
-            .createHmac('sha256', privateKey)
-            .update(content)
-            .digest('hex');
-        const publicKey = 'ed25519:' +
-            crypto.createHash('sha256').update(privateKey).digest('hex').slice(0, 32);
+    async signContent(content, privateKeyPath) {
+        const ed = await import('@noble/ed25519');
+        const raw = fs.readFileSync(privateKeyPath, 'utf-8').trim();
+        const seed = Buffer.from(raw, 'hex');
+        if (seed.length !== 32 || seed.toString('hex') !== raw.toLowerCase()) {
+            throw new Error(`[Publish] Ed25519 private key at ${privateKeyPath} must be a 32-byte hex seed.`);
+        }
+        const pub = await ed.getPublicKeyAsync(seed);
+        const sig = await ed.signAsync(content, seed);
         return {
-            signature: `ed25519:${signature}`,
-            publicKey,
+            signature: 'ed25519:' + Buffer.from(sig).toString('hex'),
+            publicKey: 'ed25519:' + Buffer.from(pub).toString('hex'),
         };
     }
     /**

package/node_modules/@claude-flow/plugin-agent-federation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/plugin-agent-federation",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Cross-installation agent federation with zero-trust security, PII-gated data flow, and compliance-grade audit trails.",
   "homepage": "https://github.com/ruvnet/ruflo",
   "type": "module",
@@ -26,7 +26,7 @@
     "@claude-flow/shared": "^3.0.0",
     "@claude-flow/security": "^3.0.0",
     "@types/ws": "^8.18.1",
-    "agentic-flow": "2.0.12-fix.8",
+    "agentic-flow": "2.0.14",
     "typescript": "^5.4.0",
     "vitest": "^4.1.0"
   },
@@ -46,11 +46,11 @@
     "sourceDependencies": {
       "dependencies": {
         "@noble/ed25519": "^2.0.0",
-        "ws": "^8.20.0"
+        "ws": "^8.21.0"
       },
       "peerDependencies": {
-        "agentic-flow": ">=2.0.12-fix.8 <4.0.0",
-        "midstreamer": ">=0.3.1"
+        "agentic-flow": "^2.0.14 || ^3.0.0",
+        "midstreamer": "^0.3.2"
       },
       "peerDependenciesMeta": {
         "agentic-flow": {

package/node_modules/@claude-flow/security/dist/input-validator.d.ts

@@ -54,7 +54,7 @@ export declare const EmailSchema: z.ZodString;
 /**
  * Password schema with complexity requirements
  */
-export declare const PasswordSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+export declare const PasswordSchema: z.ZodString;
 /**
  * UUID schema
  */
@@ -62,7 +62,7 @@ export declare const UUIDSchema: z.ZodString;
 /**
  * URL schema with HTTPS enforcement
  */
-export declare const HttpsUrlSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const HttpsUrlSchema: z.ZodString;
 /**
  * URL schema (allows HTTP for development)
  */
@@ -78,19 +78,40 @@ export declare const PortSchema: z.ZodNumber;
 /**
  * IP address schema (v4)
  */
-export declare const IPv4Schema: z.ZodString;
+export declare const IPv4Schema: z.ZodIPv4;
 /**
  * IP address schema (v4 or v6)
  */
-export declare const IPSchema: z.ZodString;
+export declare const IPSchema: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
 /**
  * User role schema
  */
-export declare const UserRoleSchema: z.ZodEnum<["admin", "operator", "developer", "viewer", "service"]>;
+export declare const UserRoleSchema: z.ZodEnum<{
+    admin: "admin";
+    operator: "operator";
+    developer: "developer";
+    viewer: "viewer";
+    service: "service";
+}>;
 /**
  * Permission schema
  */
-export declare const PermissionSchema: z.ZodEnum<["swarm.create", "swarm.read", "swarm.update", "swarm.delete", "swarm.scale", "agent.spawn", "agent.read", "agent.terminate", "task.create", "task.read", "task.cancel", "metrics.read", "system.admin", "api.access"]>;
+export declare const PermissionSchema: z.ZodEnum<{
+    "swarm.create": "swarm.create";
+    "swarm.read": "swarm.read";
+    "swarm.update": "swarm.update";
+    "swarm.delete": "swarm.delete";
+    "swarm.scale": "swarm.scale";
+    "agent.spawn": "agent.spawn";
+    "agent.read": "agent.read";
+    "agent.terminate": "agent.terminate";
+    "task.create": "task.create";
+    "task.read": "task.read";
+    "task.cancel": "task.cancel";
+    "metrics.read": "metrics.read";
+    "system.admin": "system.admin";
+    "api.access": "api.access";
+}>;
 /**
  * Login request schema
  */
@@ -98,106 +119,145 @@ export declare const LoginRequestSchema: z.ZodObject<{
     email: z.ZodString;
     password: z.ZodString;
     mfaCode: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    email: string;
-    password: string;
-    mfaCode?: string | undefined;
-}, {
-    email: string;
-    password: string;
-    mfaCode?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * User creation schema
  */
 export declare const CreateUserSchema: z.ZodObject<{
     email: z.ZodString;
-    password: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
-    role: z.ZodEnum<["admin", "operator", "developer", "viewer", "service"]>;
-    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<["swarm.create", "swarm.read", "swarm.update", "swarm.delete", "swarm.scale", "agent.spawn", "agent.read", "agent.terminate", "task.create", "task.read", "task.cancel", "metrics.read", "system.admin", "api.access"]>, "many">>;
+    password: z.ZodString;
+    role: z.ZodEnum<{
+        admin: "admin";
+        operator: "operator";
+        developer: "developer";
+        viewer: "viewer";
+        service: "service";
+    }>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "swarm.create": "swarm.create";
+        "swarm.read": "swarm.read";
+        "swarm.update": "swarm.update";
+        "swarm.delete": "swarm.delete";
+        "swarm.scale": "swarm.scale";
+        "agent.spawn": "agent.spawn";
+        "agent.read": "agent.read";
+        "agent.terminate": "agent.terminate";
+        "task.create": "task.create";
+        "task.read": "task.read";
+        "task.cancel": "task.cancel";
+        "metrics.read": "metrics.read";
+        "system.admin": "system.admin";
+        "api.access": "api.access";
+    }>>>;
     isActive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    email: string;
-    password: string;
-    role: "admin" | "operator" | "developer" | "viewer" | "service";
-    isActive: boolean;
-    permissions?: ("swarm.create" | "swarm.read" | "swarm.update" | "swarm.delete" | "swarm.scale" | "agent.spawn" | "agent.read" | "agent.terminate" | "task.create" | "task.read" | "task.cancel" | "metrics.read" | "system.admin" | "api.access")[] | undefined;
-}, {
-    email: string;
-    password: string;
-    role: "admin" | "operator" | "developer" | "viewer" | "service";
-    permissions?: ("swarm.create" | "swarm.read" | "swarm.update" | "swarm.delete" | "swarm.scale" | "agent.spawn" | "agent.read" | "agent.terminate" | "task.create" | "task.read" | "task.cancel" | "metrics.read" | "system.admin" | "api.access")[] | undefined;
-    isActive?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * API key creation schema
  */
 export declare const CreateApiKeySchema: z.ZodObject<{
     name: z.ZodString;
-    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<["swarm.create", "swarm.read", "swarm.update", "swarm.delete", "swarm.scale", "agent.spawn", "agent.read", "agent.terminate", "task.create", "task.read", "task.cancel", "metrics.read", "system.admin", "api.access"]>, "many">>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "swarm.create": "swarm.create";
+        "swarm.read": "swarm.read";
+        "swarm.update": "swarm.update";
+        "swarm.delete": "swarm.delete";
+        "swarm.scale": "swarm.scale";
+        "agent.spawn": "agent.spawn";
+        "agent.read": "agent.read";
+        "agent.terminate": "agent.terminate";
+        "task.create": "task.create";
+        "task.read": "task.read";
+        "task.cancel": "task.cancel";
+        "metrics.read": "metrics.read";
+        "system.admin": "system.admin";
+        "api.access": "api.access";
+    }>>>;
     expiresAt: z.ZodOptional<z.ZodDate>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    permissions?: ("swarm.create" | "swarm.read" | "swarm.update" | "swarm.delete" | "swarm.scale" | "agent.spawn" | "agent.read" | "agent.terminate" | "task.create" | "task.read" | "task.cancel" | "metrics.read" | "system.admin" | "api.access")[] | undefined;
-    expiresAt?: Date | undefined;
-}, {
-    name: string;
-    permissions?: ("swarm.create" | "swarm.read" | "swarm.update" | "swarm.delete" | "swarm.scale" | "agent.spawn" | "agent.read" | "agent.terminate" | "task.create" | "task.read" | "task.cancel" | "metrics.read" | "system.admin" | "api.access")[] | undefined;
-    expiresAt?: Date | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Agent type schema
  */
-export declare const AgentTypeSchema: z.ZodEnum<["coder", "reviewer", "tester", "planner", "researcher", "security-architect", "security-auditor", "memory-specialist", "swarm-specialist", "integration-architect", "performance-engineer", "core-architect", "test-architect", "queen-coordinator", "project-coordinator"]>;
+export declare const AgentTypeSchema: z.ZodEnum<{
+    coder: "coder";
+    reviewer: "reviewer";
+    tester: "tester";
+    planner: "planner";
+    researcher: "researcher";
+    "security-architect": "security-architect";
+    "security-auditor": "security-auditor";
+    "memory-specialist": "memory-specialist";
+    "swarm-specialist": "swarm-specialist";
+    "integration-architect": "integration-architect";
+    "performance-engineer": "performance-engineer";
+    "core-architect": "core-architect";
+    "test-architect": "test-architect";
+    "queen-coordinator": "queen-coordinator";
+    "project-coordinator": "project-coordinator";
+}>;
 /**
  * Agent spawn request schema
  */
 export declare const SpawnAgentSchema: z.ZodObject<{
-    type: z.ZodEnum<["coder", "reviewer", "tester", "planner", "researcher", "security-architect", "security-auditor", "memory-specialist", "swarm-specialist", "integration-architect", "performance-engineer", "core-architect", "test-architect", "queen-coordinator", "project-coordinator"]>;
+    type: z.ZodEnum<{
+        coder: "coder";
+        reviewer: "reviewer";
+        tester: "tester";
+        planner: "planner";
+        researcher: "researcher";
+        "security-architect": "security-architect";
+        "security-auditor": "security-auditor";
+        "memory-specialist": "memory-specialist";
+        "swarm-specialist": "swarm-specialist";
+        "integration-architect": "integration-architect";
+        "performance-engineer": "performance-engineer";
+        "core-architect": "core-architect";
+        "test-architect": "test-architect";
+        "queen-coordinator": "queen-coordinator";
+        "project-coordinator": "project-coordinator";
+    }>;
     id: z.ZodOptional<z.ZodString>;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timeout: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    type: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
-    config?: Record<string, unknown> | undefined;
-    timeout?: number | undefined;
-    id?: string | undefined;
-}, {
-    type: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
-    config?: Record<string, unknown> | undefined;
-    timeout?: number | undefined;
-    id?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Task input schema
  */
 export declare const TaskInputSchema: z.ZodObject<{
     taskId: z.ZodString;
     content: z.ZodString;
-    agentType: z.ZodEnum<["coder", "reviewer", "tester", "planner", "researcher", "security-architect", "security-auditor", "memory-specialist", "swarm-specialist", "integration-architect", "performance-engineer", "core-architect", "test-architect", "queen-coordinator", "project-coordinator"]>;
-    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    agentType: z.ZodEnum<{
+        coder: "coder";
+        reviewer: "reviewer";
+        tester: "tester";
+        planner: "planner";
+        researcher: "researcher";
+        "security-architect": "security-architect";
+        "security-auditor": "security-auditor";
+        "memory-specialist": "memory-specialist";
+        "swarm-specialist": "swarm-specialist";
+        "integration-architect": "integration-architect";
+        "performance-engineer": "performance-engineer";
+        "core-architect": "core-architect";
+        "test-architect": "test-architect";
+        "queen-coordinator": "queen-coordinator";
+        "project-coordinator": "project-coordinator";
+    }>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    taskId: string;
-    content: string;
-    agentType: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
-    priority?: "critical" | "high" | "medium" | "low" | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    taskId: string;
-    content: string;
-    agentType: "coder" | "reviewer" | "tester" | "planner" | "researcher" | "security-architect" | "security-auditor" | "memory-specialist" | "swarm-specialist" | "integration-architect" | "performance-engineer" | "core-architect" | "test-architect" | "queen-coordinator" | "project-coordinator";
-    priority?: "critical" | "high" | "medium" | "low" | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Command argument schema
  */
-export declare const CommandArgumentSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const CommandArgumentSchema: z.ZodString;
 /**
  * Path schema
  */
-export declare const PathSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const PathSchema: z.ZodString;
 /**
  * Security configuration schema
  */
@@ -208,46 +268,18 @@ export declare const SecurityConfigSchema: z.ZodObject<{
     maxLoginAttempts: z.ZodDefault<z.ZodNumber>;
     lockoutDuration: z.ZodDefault<z.ZodNumber>;
     requireMFA: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    bcryptRounds: number;
-    jwtExpiresIn: string;
-    sessionTimeout: number;
-    maxLoginAttempts: number;
-    lockoutDuration: number;
-    requireMFA: boolean;
-}, {
-    bcryptRounds?: number | undefined;
-    jwtExpiresIn?: string | undefined;
-    sessionTimeout?: number | undefined;
-    maxLoginAttempts?: number | undefined;
-    lockoutDuration?: number | undefined;
-    requireMFA?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Executor configuration schema
  */
 export declare const ExecutorConfigSchema: z.ZodObject<{
-    allowedCommands: z.ZodArray<z.ZodString, "many">;
-    blockedPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedCommands: z.ZodArray<z.ZodString>;
+    blockedPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout: z.ZodDefault<z.ZodNumber>;
     maxBuffer: z.ZodDefault<z.ZodNumber>;
-    cwd: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    cwd: z.ZodOptional<z.ZodString>;
     allowSudo: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    allowedCommands: string[];
-    timeout: number;
-    maxBuffer: number;
-    allowSudo: boolean;
-    blockedPatterns?: string[] | undefined;
-    cwd?: string | undefined;
-}, {
-    allowedCommands: string[];
-    blockedPatterns?: string[] | undefined;
-    timeout?: number | undefined;
-    maxBuffer?: number | undefined;
-    cwd?: string | undefined;
-    allowSudo?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Sanitizes a string by removing dangerous characters
  */
@@ -264,11 +296,11 @@ export declare class InputValidator {
     /**
      * Validates input against a schema
      */
-    static validate<T>(schema: z.ZodSchema<T>, input: unknown): T;
+    static validate<T>(schema: z.ZodType<T>, input: unknown): T;
     /**
      * Safely validates input, returning result
      */
-    static safeParse<T>(schema: z.ZodSchema<T>, input: unknown): z.SafeParseReturnType<unknown, T>;
+    static safeParse<T>(schema: z.ZodType<T>, input: unknown): z.ZodSafeParseResult<T>;
     /**
      * Validates email
      */