@defai.digital/automatosx 11.3.4 → 11.4.0

package/dist/index.js

@@ -2,15 +2,15 @@
 import * as path4 from 'path';
 import path4__default, { dirname, join, isAbsolute, basename, resolve, extname as extname$1, relative, sep, normalize, parse as parse$1, delimiter } from 'path';
 import { fileURLToPath } from 'url';
-import * as fs5 from 'fs/promises';
+import * as fs6 from 'fs/promises';
 import { mkdir, appendFile, access as access$1, readFile, stat, rm, readdir, copyFile, writeFile, rename, unlink, constants as constants$1, realpath as realpath$1 } from 'fs/promises';
-import * as fs3 from 'fs';
+import * as fs4 from 'fs';
 import { access, realpath, existsSync, readFileSync, constants, writeFileSync, mkdirSync, promises, statSync, readdirSync, createWriteStream, unlinkSync } from 'fs';
 import Database2 from 'better-sqlite3';
 import os2, { homedir, cpus } from 'os';
 import { findUp } from 'find-up';
 import { glob } from 'glob';
-import { exec, spawn, execSync, spawnSync } from 'child_process';
+import { exec, spawn, execSync, execFile, spawnSync } from 'child_process';
 import { z, ZodError } from 'zod';
 import chalk5 from 'chalk';
 import ora8 from 'ora';
@@ -18,7 +18,7 @@ import * as readline2 from 'readline';
 import readline2__default, { createInterface } from 'readline';
 import { Mutex } from 'async-mutex';
 import { promisify } from 'util';
-import crypto2, { randomUUID, createHash } from 'crypto';
+import crypto4, { randomUUID, createHash, randomBytes } from 'crypto';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import * as yaml4 from 'js-yaml';
@@ -30,6 +30,7 @@ import addFormats from 'ajv-formats';
 import { EventEmitter } from 'events';
 import * as sqliteVec from 'sqlite-vec';
 import yaml from 'yaml';
+import { gzipSync, gunzipSync } from 'zlib';
 import { parse } from '@iarna/toml';
 
 var __defProp = Object.defineProperty;
@@ -743,16 +744,16 @@ var init_errors = __esm({
       constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
         super(message, code, suggestions, context);
       }
-      static notFound(path8) {
+      static notFound(path9) {
         return new _ConfigError(
-          `Configuration file not found: ${path8}`,
+          `Configuration file not found: ${path9}`,
           "E1000" /* CONFIG_NOT_FOUND */,
           [
             'Run "automatosx setup" to create a new configuration',
             "Specify a custom config path with --config option",
             "Check that you are in a valid AutomatosX project directory"
           ],
-          { path: path8 }
+          { path: path9 }
         );
       }
       static invalid(reason, context) {
@@ -767,7 +768,7 @@ var init_errors = __esm({
           context
         );
       }
-      static parseError(error, path8) {
+      static parseError(error, path9) {
         return new _ConfigError(
           `Failed to parse configuration: ${error.message}`,
           "E1002" /* CONFIG_PARSE_ERROR */,
@@ -776,7 +777,7 @@ var init_errors = __esm({
             "Use a JSON validator to find syntax errors",
             'Reset to default with "automatosx setup --force"'
           ],
-          { path: path8, originalError: error.message }
+          { path: path9, originalError: error.message }
         );
       }
     };
@@ -1004,8 +1005,8 @@ __export(path_resolver_exports, {
   PathResolver: () => PathResolver,
   detectProjectRoot: () => detectProjectRoot
 });
-function isWindowsPath(path8) {
-  return /^[a-zA-Z]:[/\\]/.test(path8);
+function isWindowsPath(path9) {
+  return /^[a-zA-Z]:[/\\]/.test(path9);
 }
 async function detectProjectRoot(startDir = process.cwd()) {
   if (process.env.AUTOMATOSX_PROJECT_ROOT) {
@@ -1111,8 +1112,8 @@ var init_path_resolver = __esm({
       /**
        * Validate path is within allowed base directory
        */
-      validatePath(path8, baseDir) {
-        const normalized = normalizePath(resolvePath(path8));
+      validatePath(path9, baseDir) {
+        const normalized = normalizePath(resolvePath(path9));
         const base = normalizePath(resolvePath(baseDir));
         const separator = "/";
         const pathWithSep = normalized + separator;
@@ -1122,15 +1123,15 @@ var init_path_resolver = __esm({
       /**
        * Check if path is within allowed boundaries
        */
-      isPathAllowed(path8) {
-        const boundary = this.checkBoundaries(path8);
+      isPathAllowed(path9) {
+        const boundary = this.checkBoundaries(path9);
         return boundary === "agent_workspace" || boundary === "user_project";
       }
       /**
        * Check which boundary a path belongs to
        */
-      checkBoundaries(path8) {
-        const normalized = resolvePath(path8);
+      checkBoundaries(path9) {
+        const normalized = resolvePath(path9);
         if (this.validatePath(normalized, this.config.agentWorkspace)) {
           return "agent_workspace";
         }
@@ -1148,15 +1149,15 @@ var init_path_resolver = __esm({
       /**
        * Get relative path from project root
        */
-      getRelativeToProject(path8) {
-        const normalized = resolvePath(path8);
+      getRelativeToProject(path9) {
+        const normalized = resolvePath(path9);
         return normalizePath(getRelativePath(this.config.projectDir, normalized));
       }
       /**
        * Get relative path from working directory
        */
-      getRelativeToWorking(path8) {
-        const normalized = resolvePath(path8);
+      getRelativeToWorking(path9) {
+        const normalized = resolvePath(path9);
         return normalizePath(getRelativePath(this.config.workingDir, normalized));
       }
       /**
@@ -1175,11 +1176,11 @@ var init_path_resolver = __esm({
        * Validate path is within project boundaries
        * @throws PathError if outside project
        */
-      validateInProject(path8) {
-        const boundary = this.checkBoundaries(path8);
+      validateInProject(path9) {
+        const boundary = this.checkBoundaries(path9);
         if (boundary === "outside_boundaries" || boundary === "system_restricted") {
           throw new PathError("Path outside project directory", {
-            path: path8,
+            path: path9,
             projectDir: this.config.projectDir,
             boundary
           });
@@ -1422,11 +1423,11 @@ var init_workspace_indexer = __esm({
       /**
        * Detect file type and language
        */
-      detectTypeAndLanguage(path8, ext) {
-        if (path8.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
+      detectTypeAndLanguage(path9, ext) {
+        if (path9.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
           return { type: "config", language: "json" };
         }
-        if (path8.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path8.includes("__tests__")) {
+        if (path9.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path9.includes("__tests__")) {
           const lang = LANGUAGE_MAP[ext];
           return { type: "test", language: lang };
         }
@@ -1443,15 +1444,15 @@ var init_workspace_indexer = __esm({
        *
        * Higher score = more likely to be relevant
        */
-      calculateImportance(path8, type, size) {
+      calculateImportance(path9, type, size) {
         let score = 0.5;
-        if (path8.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
-        if (path8.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
-        if (path8.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
+        if (path9.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
+        if (path9.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
+        if (path9.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
         if (type === "config") score = 0.85;
-        if (path8.includes("/core/")) score += 0.15;
-        if (path8.includes("/types/")) score += 0.1;
-        if (path8.includes("/utils/")) score += 0.05;
+        if (path9.includes("/core/")) score += 0.15;
+        if (path9.includes("/types/")) score += 0.1;
+        if (path9.includes("/utils/")) score += 0.05;
         if (type === "test") score = Math.max(0.3, score - 0.3);
         if (type === "doc") score = Math.max(0.4, score - 0.2);
         if (size > 1e4) score += 0.05;
@@ -1927,10 +1928,10 @@ function findOnPathUnix(cmdBase) {
   try {
     const which = spawnSync("which", [cmdBase], { timeout: 3e3 });
     if (which.status === 0) {
-      const path8 = which.stdout.toString().trim();
-      if (path8) {
-        logger.debug("Found via which", { cmdBase, path: path8 });
-        return { found: true, path: path8 };
+      const path9 = which.stdout.toString().trim();
+      if (path9) {
+        logger.debug("Found via which", { cmdBase, path: path9 });
+        return { found: true, path: path9 };
       }
     }
   } catch (error) {
@@ -3058,7 +3059,7 @@ ${request.prompt}`;
           }
           if (process.env.AUTOMATOSX_DEBUG_PROMPT === "true") {
             const debugPath = path4.join(process.cwd(), "automatosx/tmp/debug-prompt.txt");
-            fs3.writeFileSync(debugPath, `=== FULL PROMPT SENT TO ${this.getCLICommand()} ===
+            fs4.writeFileSync(debugPath, `=== FULL PROMPT SENT TO ${this.getCLICommand()} ===
 
 ${fullPrompt}
 
@@ -4754,13 +4755,14 @@ var init_response_parser = __esm({
     };
   }
 });
-var execAsync3, AxCliAdapter;
+var execFileAsync, execAsync3, AxCliAdapter;
 var init_adapter = __esm({
   "src/integrations/ax-cli/adapter.ts"() {
     init_esm_shims();
     init_command_builder();
     init_response_parser();
     init_logger();
+    execFileAsync = promisify(execFile);
     execAsync3 = promisify(exec);
     AxCliAdapter = class {
       command = "ax-cli";
@@ -4792,7 +4794,7 @@ var init_adapter = __esm({
           model: options.model
         });
         try {
-          const { stdout, stderr } = await execAsync3(`${command} ${args.join(" ")}`, {
+          const { stdout, stderr } = await execFileAsync(command, args, {
             timeout,
             maxBuffer: 10 * 1024 * 1024,
             // 10MB
@@ -4818,14 +4820,29 @@ var init_adapter = __esm({
             latencyMs
           };
         } catch (error) {
+          const latencyMs = Date.now() - startTime;
+          const execError = error;
+          const stderr = execError.stderr || "";
+          const stdout = execError.stdout || "";
+          const exitCode = execError.code;
           logger.error("ax-cli execution failed", {
             error: error instanceof Error ? error.message : String(error),
-            command: fullCommand
+            command: fullCommand,
+            exitCode,
+            stderr: stderr.substring(0, 500),
+            latencyMs
           });
-          if (error instanceof Error) {
-            throw new Error(`ax-cli execution failed: ${error.message}`);
+          let errorMessage = error instanceof Error ? error.message : String(error);
+          const extractedError = this.responseParser.extractError(stderr || stdout);
+          if (extractedError) {
+            errorMessage = extractedError;
           }
-          throw error;
+          const wrappedError = new Error(`ax-cli execution failed: ${errorMessage}`);
+          wrappedError.exitCode = exitCode;
+          wrappedError.stderr = stderr;
+          wrappedError.stdout = stdout;
+          wrappedError.latencyMs = latencyMs;
+          throw wrappedError;
         }
       }
       /**
@@ -5224,14 +5241,18 @@ ${task.task}` : task.task;
           let totalTokens = 0;
           const timeoutMs = this.options.timeout;
           let timeoutTimer = null;
+          let timedOut = false;
+          let streamPromise = null;
           try {
             const timeoutPromise = new Promise((_, reject) => {
               timeoutTimer = setTimeout(() => {
+                timedOut = true;
                 reject(new Error(`Subagent task timed out after ${timeoutMs}ms`));
               }, timeoutMs);
             });
-            const streamPromise = (async () => {
+            streamPromise = (async () => {
               for await (const chunk of subagent.processUserMessageStream(prompt)) {
+                if (timedOut) break;
                 if (chunk.type === "content") {
                   content += chunk.content || "";
                 }
@@ -5246,6 +5267,26 @@ ${task.task}` : task.task;
               clearTimeout(timeoutTimer);
               timeoutTimer = null;
             }
+            if (timedOut) {
+              try {
+                if (typeof subagent.dispose === "function") {
+                  const disposeResult = subagent.dispose();
+                  if (disposeResult instanceof Promise) {
+                    await disposeResult.catch(() => {
+                    });
+                  }
+                }
+                if (streamPromise) {
+                  await Promise.race([
+                    streamPromise.catch(() => {
+                    }),
+                    new Promise((resolve13) => setTimeout(resolve13, 1e3))
+                    // 1s max wait
+                  ]);
+                }
+              } catch {
+              }
+            }
           }
           const latencyMs = Date.now() - startTime;
           this.emitEvent("task_complete", task.task, content);
@@ -5709,8 +5750,8 @@ var init_checkpoint_adapter = __esm({
        */
       async list(workflowId) {
         try {
-          await fs5.mkdir(this.checkpointDir, { recursive: true });
-          const files = await fs5.readdir(this.checkpointDir);
+          await fs6.mkdir(this.checkpointDir, { recursive: true });
+          const files = await fs6.readdir(this.checkpointDir);
           const prefix = `${workflowId}-`;
           const matchingFiles = files.filter((file) => {
             if (!file.startsWith(prefix) || !file.endsWith(".json")) {
@@ -5722,7 +5763,7 @@ var init_checkpoint_adapter = __esm({
           const results = await Promise.all(
             matchingFiles.map(async (file) => {
               try {
-                const content = await fs5.readFile(
+                const content = await fs6.readFile(
                   path4.join(this.checkpointDir, file),
                   "utf-8"
                 );
@@ -5830,7 +5871,7 @@ ${result.content.substring(0, 1e3)}
         await this.sdkCheckpointManager.delete(workflowId);
       }
       async saveToFileSystem(checkpoint) {
-        await fs5.mkdir(this.checkpointDir, { recursive: true });
+        await fs6.mkdir(this.checkpointDir, { recursive: true });
         const filename = `${checkpoint.workflowId}-${checkpoint.phase}.json`;
         const filepath = path4.join(this.checkpointDir, filename);
         const content = JSON.stringify(checkpoint, null, 2);
@@ -5850,7 +5891,7 @@ ${result.content.substring(0, 1e3)}
        */
       async deleteFromFileSystem(workflowId) {
         try {
-          const files = await fs5.readdir(this.checkpointDir);
+          const files = await fs6.readdir(this.checkpointDir);
           const prefix = `${workflowId}-`;
           for (const file of files) {
             if (!file.startsWith(prefix) || !file.endsWith(".json")) {
@@ -5858,7 +5899,7 @@ ${result.content.substring(0, 1e3)}
             }
             const middle = file.slice(prefix.length, -5);
             if (/^\d+$/.test(middle)) {
-              await fs5.unlink(path4.join(this.checkpointDir, file));
+              await fs6.unlink(path4.join(this.checkpointDir, file));
             }
           }
         } catch (error) {
@@ -5876,7 +5917,7 @@ ${result.content.substring(0, 1e3)}
           for (const checkpoint of toDelete) {
             try {
               const filename = `${checkpoint.workflowId}-${checkpoint.phase}.json`;
-              await fs5.unlink(path4.join(this.checkpointDir, filename));
+              await fs6.unlink(path4.join(this.checkpointDir, filename));
             } catch {
             }
           }
@@ -5920,6 +5961,9 @@ ${result.content.substring(0, 1e3)}
             }
           }
         }, this.options.autoSaveInterval);
+        if (this.autoSaveTimer && typeof this.autoSaveTimer.unref === "function") {
+          this.autoSaveTimer.unref();
+        }
       }
       /**
        * Mark checkpoint for auto-save
@@ -6002,12 +6046,12 @@ ${result.content.substring(0, 1e3)}
        */
       async atomicWrite(filepath, content) {
         const tempFile = `${filepath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-        await fs5.writeFile(tempFile, content, "utf-8");
+        await fs6.writeFile(tempFile, content, "utf-8");
         try {
-          await fs5.rename(tempFile, filepath);
+          await fs6.rename(tempFile, filepath);
         } catch (renameError) {
           try {
-            await fs5.unlink(tempFile);
+            await fs6.unlink(tempFile);
           } catch {
           }
           throw renameError;
@@ -6139,7 +6183,7 @@ var init_instructions_bridge = __esm({
       async loadAgentProfile(agentName) {
         const profilePath = path4.join(this.options.agentsDir, `${agentName}.ax.yaml`);
         try {
-          const content = await fs5.readFile(profilePath, "utf-8");
+          const content = await fs6.readFile(profilePath, "utf-8");
           const profile = this.parseYamlProfile(content);
           logger.debug("Agent profile loaded", { agentName, profilePath });
           return profile;
@@ -6174,7 +6218,7 @@ var init_instructions_bridge = __esm({
           }
         }
         try {
-          const content = await fs5.readFile(this.options.axCliCustomPath, "utf-8");
+          const content = await fs6.readFile(this.options.axCliCustomPath, "utf-8");
           logger.debug("Custom instructions loaded from file", {
             path: this.options.axCliCustomPath
           });
@@ -6198,11 +6242,18 @@ var init_instructions_bridge = __esm({
         try {
           const sdk = await import('@defai.digital/ax-cli/sdk');
           if (sdk.buildSystemPrompt) {
-            const fullPrompt = sdk.buildSystemPrompt({
+            const buildResult = sdk.buildSystemPrompt({
               customInstructions: "",
               includeMemory: true
             });
-            const contextMatch = fullPrompt?.match(/## Project Context\n\n([\s\S]*?)(?=\n##|$)/);
+            const fullPrompt = buildResult instanceof Promise ? await buildResult : buildResult;
+            if (typeof fullPrompt !== "string") {
+              logger.debug("buildSystemPrompt did not return a string", {
+                type: typeof fullPrompt
+              });
+              return "";
+            }
+            const contextMatch = fullPrompt.match(/## Project Context\n\n([\s\S]*?)(?=\n##|$)/);
             if (contextMatch && contextMatch[1]) {
               logger.debug("Project memory loaded via SDK");
               return contextMatch[1].trim();
@@ -6332,8 +6383,8 @@ ${profile.expertise.map((e) => `- ${e}`).join("\n")}
 ${profile.instructions}
 `;
         try {
-          await fs5.mkdir(path4.dirname(this.options.axCliCustomPath), { recursive: true });
-          await fs5.writeFile(this.options.axCliCustomPath, customContent, "utf-8");
+          await fs6.mkdir(path4.dirname(this.options.axCliCustomPath), { recursive: true });
+          await fs6.writeFile(this.options.axCliCustomPath, customContent, "utf-8");
           logger.info("Agent synced to ax-cli custom instructions", {
             agentName,
             path: this.options.axCliCustomPath
@@ -6389,7 +6440,7 @@ ${profile.instructions}
       }
       async getFileSignature(filePath) {
         try {
-          const stats = await fs5.stat(filePath);
+          const stats = await fs6.stat(filePath);
           return `${stats.mtimeMs}:${stats.size}`;
         } catch {
           return "missing";
@@ -6582,6 +6633,12 @@ var init_mcp_manager = __esm({
           const { MCPManager } = this.mcpModule;
           if (MCPManager?.loadMCPConfig) {
             const config = await MCPManager.loadMCPConfig();
+            if (config === null || config === void 0) {
+              return { ok: false, error: new Error("loadMCPConfig returned null/undefined") };
+            }
+            if (typeof config !== "object" || Array.isArray(config)) {
+              return { ok: false, error: new Error(`loadMCPConfig returned invalid type: ${typeof config}`) };
+            }
             return { ok: true, value: config };
           }
           return { ok: false, error: new Error("loadMCPConfig not available in SDK") };
@@ -7297,7 +7354,7 @@ var init_adapter2 = __esm({
         const { createAgent } = await import('@defai.digital/ax-cli/sdk');
         try {
           const config = {
-            maxToolRounds: options.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS
+            maxToolRounds: options.maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS
           };
           logger.debug("Creating SDK agent (credentials from ax-cli settings)", {
             maxToolRounds: config.maxToolRounds,
@@ -7359,11 +7416,11 @@ var init_adapter2 = __esm({
        */
       hasConfigChanged(options) {
         if (!this.agentConfig) return true;
-        const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS);
+        const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS);
         if (changed) {
           logger.debug("Agent config changed, will reinitialize", {
             oldMaxToolRounds: this.agentConfig.maxToolRounds,
-            newMaxToolRounds: options.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS,
+            newMaxToolRounds: options.maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS,
             note: "SDK credentials managed by ax-cli setup"
           });
         }
@@ -7472,15 +7529,18 @@ var init_adapter2 = __esm({
           return tokens;
         }
         const usage = usageObject || {};
+        const promptTokens = Number(usage.prompt_tokens ?? usage.prompt ?? usage.input ?? usage.promptTokens ?? 0) || 0;
+        const completionTokens = Number(usage.completion_tokens ?? usage.completion ?? usage.output ?? usage.completionTokens ?? 0) || 0;
+        const totalFromUsage = Number(usage.total_tokens ?? usage.total ?? usage.totalTokens ?? 0) || 0;
         const actualTokens = {
-          prompt: usage.prompt_tokens ?? usage.prompt ?? usage.input ?? usage.promptTokens ?? 0,
-          completion: usage.completion_tokens ?? usage.completion ?? usage.output ?? usage.completionTokens ?? 0,
-          total: usage.total_tokens ?? usage.total ?? usage.totalTokens ?? 0
+          prompt: promptTokens,
+          completion: completionTokens,
+          total: totalFromUsage > 0 ? totalFromUsage : promptTokens + completionTokens
         };
         if (actualTokens.total > 0) {
           logger.info(`Using token counts from ${sourceName || "usage object"}`, {
             tokens: TokenEstimator.format(actualTokens),
-            accuracy: "100%",
+            accuracy: totalFromUsage > 0 ? "100%" : "100% (derived from prompt+completion)",
             source: sourceName || "usage"
           });
           return actualTokens;
@@ -8094,8 +8154,11 @@ var init_ax_cli_provider = __esm({
         const options = {
           model: request.model || axCliConfig.model,
           // Optional model override
-          maxToolRounds: axCliConfig.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS2,
+          maxToolRounds: axCliConfig.maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS2,
           timeout: this.config.timeout,
+          // BUG FIX: Force JSON output for CLI adapter to ensure proper parsing
+          // Without this, the response parser expects JSONL but gets plain text
+          json: true,
           // Note: apiKey and baseUrl are ignored by SDK adapter (v3.7.0+)
           // SDK loads credentials from ax-cli setup (~/.ax-cli/config.json)
           apiKey: axCliConfig.apiKey,
@@ -9349,11 +9412,11 @@ var VALIDATION_LIMITS = {
   MAX_PORT: 65535
   // Maximum port number
 };
-function isValidRelativePath(path8) {
-  if (!path8 || typeof path8 !== "string") {
+function isValidRelativePath(path9) {
+  if (!path9 || typeof path9 !== "string") {
     return false;
   }
-  const normalizedPath = path8.replace(/\\/g, "/");
+  const normalizedPath = path9.replace(/\\/g, "/");
   if (normalizedPath.startsWith("/")) {
     return false;
   }
@@ -10070,7 +10133,7 @@ var safeNameSchema = z.string().min(1).max(VALIDATION_LIMITS.MAX_NAME_LENGTH).re
   "Name must be alphanumeric with dash/underscore only"
 ).describe("Safe identifier name");
 var relativePathSchema = z.string().min(1).refine(
-  (path8) => !path8.includes("..") && !path8.startsWith("/"),
+  (path9) => !path9.includes("..") && !path9.startsWith("/"),
   "Path must be relative (no ../, no absolute paths)"
 ).describe("Relative path within project");
 var fileExtensionSchema = z.string().regex(
@@ -10410,16 +10473,16 @@ async function loadConfigUncached(projectDir) {
   });
   return config;
 }
-async function loadConfigFile(path8) {
+async function loadConfigFile(path9) {
   try {
-    const content = await readFile(path8, "utf-8");
+    const content = await readFile(path9, "utf-8");
     if (content.length > VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE) {
       throw ConfigError.parseError(
         new Error(`Config file too large (max ${VALIDATION_LIMITS.MAX_CONFIG_FILE_SIZE / 1024}KB, got ${Math.ceil(content.length / 1024)}KB)`),
-        path8
+        path9
       );
     }
-    const ext = extname(path8).toLowerCase();
+    const ext = extname(path9).toLowerCase();
     let userConfig;
     try {
       if (ext === ".yaml" || ext === ".yml") {
@@ -10428,7 +10491,7 @@ async function loadConfigFile(path8) {
         userConfig = JSON.parse(content);
       }
     } catch (parseError) {
-      throw ConfigError.parseError(parseError, path8);
+      throw ConfigError.parseError(parseError, path9);
     }
     const config = mergeConfig(DEFAULT_CONFIG, userConfig);
     if (config.execution && userConfig.execution?.maxConcurrentAgents === void 0) {
@@ -10444,35 +10507,35 @@ async function loadConfigFile(path8) {
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path8, errors: validationErrors }
+        { path: path9, errors: validationErrors }
       );
     }
-    logger.info("Config loaded successfully", { path: normalizePath(path8), format: ext });
+    logger.info("Config loaded successfully", { path: normalizePath(path9), format: ext });
     return config;
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "ENOENT") {
-      throw ConfigError.notFound(path8);
+      throw ConfigError.notFound(path9);
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied reading config: ${path8}`,
+        `Permission denied reading config: ${path9}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the file is accessible"
         ],
-        { path: path8, error: error.message }
+        { path: path9, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to load config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file format and permissions"],
-      { path: path8, originalError: error.message }
+      { path: path9, originalError: error.message }
     );
   }
 }
@@ -10488,8 +10551,8 @@ function validateConfigWithZod(config) {
     return ["Configuration validation failed with unknown error structure"];
   }
   return result.error.issues.map((err) => {
-    const path8 = err.path.join(".");
-    return `${path8}: ${err.message}`;
+    const path9 = err.path.join(".");
+    return `${path9}: ${err.message}`;
   });
 }
 function validateConfig(config) {
@@ -10875,16 +10938,16 @@ function validateConfig(config) {
   }
   return errors;
 }
-async function saveConfigFile(path8, config) {
+async function saveConfigFile(path9, config) {
   try {
     const validationErrors = validateConfig(config);
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path8, errors: validationErrors }
+        { path: path9, errors: validationErrors }
       );
     }
-    const ext = extname(path8).toLowerCase();
+    const ext = extname(path9).toLowerCase();
     let content;
     if (ext === ".yaml" || ext === ".yml") {
       content = dump(config, {
@@ -10896,30 +10959,30 @@ async function saveConfigFile(path8, config) {
     } else {
       content = JSON.stringify(config, null, 2);
     }
-    await writeFile(path8, content, "utf-8");
+    await writeFile(path9, content, "utf-8");
     configCache.clear();
-    logger.info("Config saved successfully", { path: normalizePath(path8), format: ext });
+    logger.info("Config saved successfully", { path: normalizePath(path9), format: ext });
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied writing config: ${path8}`,
+        `Permission denied writing config: ${path9}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the directory is writable"
         ],
-        { path: path8, error: error.message }
+        { path: path9, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to save config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file path and permissions"],
-      { path: path8, originalError: error.message }
+      { path: path9, originalError: error.message }
     );
   }
 }
@@ -11669,10 +11732,10 @@ var configCommand = {
       } else {
         const projectConfig = resolve(process.cwd(), "ax.config.json");
         const hiddenConfig = resolve(process.cwd(), ".automatosx", "config.json");
-        const fs8 = await import('fs');
-        if (fs8.existsSync(projectConfig)) {
+        const fs9 = await import('fs');
+        if (fs9.existsSync(projectConfig)) {
           configPath = projectConfig;
-        } else if (fs8.existsSync(hiddenConfig)) {
+        } else if (fs9.existsSync(hiddenConfig)) {
           configPath = hiddenConfig;
         } else {
           configPath = projectConfig;
@@ -11719,9 +11782,9 @@ var configCommand = {
     }
   }
 };
-async function checkExists(path8) {
+async function checkExists(path9) {
   try {
-    await access$1(path8, constants.F_OK);
+    await access$1(path9, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -11752,7 +11815,7 @@ async function validateConfigFile(config, verbose) {
   }
   console.log();
 }
-async function resetConfig(path8, verbose) {
+async function resetConfig(path9, verbose) {
   const { createRequire } = await import('module');
   const require2 = createRequire(import.meta.url);
   let version = "11.2.6";
@@ -11767,14 +11830,14 @@ async function resetConfig(path8, verbose) {
     // Users should rely on IDE JSON Schema plugins that fetch from npm package
     version
   };
-  await saveConfigFile(path8, config);
+  await saveConfigFile(path9, config);
   printSuccess("Configuration reset to defaults");
   if (verbose) {
     console.log(chalk5.gray(`
-Config file: ${path8}
+Config file: ${path9}
 `));
   }
-  logger.info("Configuration reset", { path: path8 });
+  logger.info("Configuration reset", { path: path9 });
 }
 async function listConfig(config, verbose) {
   console.log(chalk5.bold.cyan("\n\u{1F4CB} AutomatosX Configuration\n"));
@@ -11853,7 +11916,7 @@ async function getConfig(config, key, verbose) {
     }
   }
 }
-async function setConfig(path8, config, key, value, verbose) {
+async function setConfig(path9, config, key, value, verbose) {
   let parsedValue = value;
   try {
     parsedValue = JSON.parse(value);
@@ -11872,21 +11935,21 @@ async function setConfig(path8, config, key, value, verbose) {
     console.log();
     process.exit(1);
   }
-  await saveConfigFile(path8, config);
+  await saveConfigFile(path9, config);
   printSuccess(`Configuration updated: ${key} = ${value}`);
   if (verbose) {
     console.log(chalk5.gray(`
-Config file: ${path8}`));
+Config file: ${path9}`));
     console.log(chalk5.gray("Configuration validated successfully\n"));
   }
   logger.info("Configuration updated", { key, value });
 }
-function getNestedValue(obj, path8) {
-  if (!path8 || !path8.trim()) return void 0;
-  return path8.split(".").filter(Boolean).reduce((current, key) => current?.[key], obj);
+function getNestedValue(obj, path9) {
+  if (!path9 || !path9.trim()) return void 0;
+  return path9.split(".").filter(Boolean).reduce((current, key) => current?.[key], obj);
 }
-function setNestedValue(obj, path8, value) {
-  const keys = path8.split(".");
+function setNestedValue(obj, path9, value) {
+  const keys = path9.split(".");
   const lastKey = keys.pop();
   if (!lastKey) return false;
   const target = keys.reduce((current, key) => {
@@ -13986,7 +14049,7 @@ var setupCommand = {
     let version = "11.2.6";
     try {
       const packageJson = JSON.parse(
-        await import('fs/promises').then((fs8) => fs8.readFile(join(packageRoot, "package.json"), "utf-8"))
+        await import('fs/promises').then((fs9) => fs9.readFile(join(packageRoot, "package.json"), "utf-8"))
       );
       version = packageJson.version;
     } catch {
@@ -14309,9 +14372,9 @@ var setupCommand = {
     }
   }
 };
-async function checkExists2(path8) {
+async function checkExists2(path9) {
   try {
-    await access$1(path8, constants.F_OK);
+    await access$1(path9, constants.F_OK);
     return true;
   } catch {
     return false;
@@ -15823,11 +15886,11 @@ async function detectExpressRoutes(projectDir) {
         while ((match = routeRegex.exec(content)) !== null) {
           if (match[1] && match[2]) {
             const method = match[1].toUpperCase();
-            const path8 = match[2];
+            const path9 = match[2];
             endpoints.push({
               method,
-              path: path8,
-              group: path8.split("/")[1] || "api"
+              path: path9,
+              group: path9.split("/")[1] || "api"
             });
           }
         }
@@ -16932,12 +16995,12 @@ var listCommand = {
 };
 async function listAgents(pathResolver, format) {
   const agentsDir = pathResolver.getAgentsDirectory();
-  const { existsSync: existsSync27 } = await import('fs');
+  const { existsSync: existsSync28 } = await import('fs');
   const projectDir = await detectProjectRoot();
   const examplesDir = join(projectDir, "examples", "agents");
   try {
     const agentFiles = [];
-    if (existsSync27(agentsDir)) {
+    if (existsSync28(agentsDir)) {
       const files = await readdir(agentsDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -16949,7 +17012,7 @@ async function listAgents(pathResolver, format) {
         }
       }
     }
-    if (existsSync27(examplesDir)) {
+    if (existsSync28(examplesDir)) {
       const files = await readdir(examplesDir);
       for (const file of files) {
         if (file.endsWith(".yaml") || file.endsWith(".yml")) {
@@ -18821,18 +18884,18 @@ var ProviderSessionManager = class {
 };
 var providerSessionInstances = /* @__PURE__ */ new Map();
 async function getProviderSession(workspacePath) {
-  let path8;
+  let path9;
   {
     if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-      path8 = process.cwd();
+      path9 = process.cwd();
     } else {
-      path8 = await detectProjectRoot();
+      path9 = await detectProjectRoot();
     }
   }
-  if (!providerSessionInstances.has(path8)) {
-    providerSessionInstances.set(path8, new ProviderSessionManager(path8));
+  if (!providerSessionInstances.has(path9)) {
+    providerSessionInstances.set(path9, new ProviderSessionManager(path9));
   }
-  return providerSessionInstances.get(path8);
+  return providerSessionInstances.get(path9);
 }
 
 // src/core/router/router.ts
@@ -24678,9 +24741,9 @@ var DependencyGraphBuilder = class {
   detectCycles(graph) {
     const visiting = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
-    const visit = (nodeName, path8) => {
+    const visit = (nodeName, path9) => {
       if (visiting.has(nodeName)) {
-        throw new Error(`Circular dependency detected: ${[...path8, nodeName].join(" \u2192 ")}`);
+        throw new Error(`Circular dependency detected: ${[...path9, nodeName].join(" \u2192 ")}`);
       }
       if (visited.has(nodeName)) {
         return;
@@ -24695,7 +24758,7 @@ var DependencyGraphBuilder = class {
       }
       visiting.add(nodeName);
       for (const dependency of node.dependencies) {
-        visit(dependency, [...path8, nodeName]);
+        visit(dependency, [...path9, nodeName]);
       }
       visiting.delete(nodeName);
       visited.add(nodeName);
@@ -26428,59 +26491,59 @@ var DANGEROUS_PATH_PATTERNS = [
   // Common data drive (Windows, alt format)
 ];
 var SUSPICIOUS_PATH_CHARS = /[<>:|"]/;
-function validatePathParameter(path8, paramName, projectRoot = process.cwd()) {
-  if (!path8 || path8.trim() === "") {
+function validatePathParameter(path9, paramName, projectRoot = process.cwd()) {
+  if (!path9 || path9.trim() === "") {
     throw new ValidationError(
       `Invalid ${paramName}: path cannot be empty`,
       -32602 /* InvalidParams */,
-      { path: path8, paramName }
+      { path: path9, paramName }
     );
   }
   for (const pattern of DANGEROUS_PATH_PATTERNS) {
-    if (path8.includes(pattern)) {
+    if (path9.includes(pattern)) {
       throw new ValidationError(
         `Invalid ${paramName}: path contains dangerous pattern "${pattern}"`,
         -32602 /* InvalidParams */,
-        { path: path8, paramName, pattern }
+        { path: path9, paramName, pattern }
       );
     }
   }
-  if (isAbsolute(path8)) {
+  if (isAbsolute(path9)) {
     throw new ValidationError(
       `Invalid ${paramName}: absolute paths are not allowed`,
       -32602 /* InvalidParams */,
-      { path: path8, paramName }
+      { path: path9, paramName }
     );
   }
   try {
-    const resolvedPath = resolve(projectRoot, path8);
+    const resolvedPath = resolve(projectRoot, path9);
     const normalizedRoot = resolve(projectRoot);
     if (!resolvedPath.startsWith(normalizedRoot + sep) && resolvedPath !== normalizedRoot) {
       throw new ValidationError(
         `Invalid ${paramName}: path escapes project boundary`,
         -32602 /* InvalidParams */,
-        { path: path8, paramName, projectRoot, resolvedPath }
+        { path: path9, paramName, projectRoot, resolvedPath }
       );
     }
   } catch (error) {
     throw new ValidationError(
       `Invalid ${paramName}: path resolution failed`,
       -32602 /* InvalidParams */,
-      { path: path8, paramName, error: String(error) }
+      { path: path9, paramName, error: String(error) }
     );
   }
-  if (path8.includes("\0")) {
+  if (path9.includes("\0")) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains null byte`,
       -32602 /* InvalidParams */,
-      { path: path8, paramName }
+      { path: path9, paramName }
     );
   }
-  if (SUSPICIOUS_PATH_CHARS.test(path8)) {
+  if (SUSPICIOUS_PATH_CHARS.test(path9)) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains invalid characters`,
       -32602 /* InvalidParams */,
-      { path: path8, paramName }
+      { path: path9, paramName }
     );
   }
 }
@@ -27176,8 +27239,8 @@ function createMemoryExportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_export called", { input });
     try {
-      const { path: path8 } = input;
-      const absolutePath = resolveExportPath(deps.pathResolver, path8);
+      const { path: path9 } = input;
+      const absolutePath = resolveExportPath(deps.pathResolver, path9);
       const exported = await deps.memoryManager.exportToJSON(absolutePath);
       const result = {
         success: true,
@@ -27213,8 +27276,8 @@ function createMemoryImportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_import called", { input });
     try {
-      const { path: path8 } = input;
-      const absolutePath = resolveImportPath(deps.pathResolver, path8);
+      const { path: path9 } = input;
+      const absolutePath = resolveImportPath(deps.pathResolver, path9);
       const imported = await deps.memoryManager.importFromJSON(absolutePath);
       const result = {
         success: true,
@@ -27569,6 +27632,1930 @@ Task: ${task}`;
   };
 }
 
+// src/mcp/tools/task/index.ts
+init_esm_shims();
+
+// src/mcp/tools/task/create-task.ts
+init_esm_shims();
+
+// src/core/task-engine/index.ts
+init_esm_shims();
+
+// src/core/task-engine/types.ts
+init_esm_shims();
+var TaskEngineError = class _TaskEngineError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "TaskEngineError";
+    Error.captureStackTrace?.(this, _TaskEngineError);
+  }
+};
+var LoopPreventionError = class extends TaskEngineError {
+  constructor(message, callChain, code = "LOOP_DETECTED") {
+    super(message, code, { callChain });
+    this.callChain = callChain;
+    this.name = "LoopPreventionError";
+  }
+};
+var TaskTypeSchema = z.enum([
+  "web_search",
+  "code_review",
+  "code_generation",
+  "analysis",
+  "custom"
+]);
+var TaskEngineSchema = z.enum([
+  "auto",
+  "gemini",
+  "claude",
+  "codex",
+  "ax-cli"
+]);
+var TaskStatusSchema = z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "expired"
+]);
+var OriginClientSchema = z.enum([
+  "claude-code",
+  "gemini-cli",
+  "codex-cli",
+  "ax-cli",
+  "unknown"
+]);
+var CreateTaskInputSchema = z.object({
+  type: TaskTypeSchema,
+  payload: z.record(z.string(), z.unknown()),
+  engine: TaskEngineSchema.default("auto"),
+  priority: z.number().int().min(1).max(10).default(5),
+  ttlHours: z.number().int().min(1).default(24).transform((v) => Math.min(v, 168)),
+  context: z.object({
+    originClient: OriginClientSchema.optional(),
+    callChain: z.array(z.string()).optional(),
+    depth: z.number().int().min(0).optional()
+  }).optional()
+});
+var TaskFilterSchema = z.object({
+  status: TaskStatusSchema.optional(),
+  engine: TaskEngineSchema.optional(),
+  type: TaskTypeSchema.optional(),
+  originClient: OriginClientSchema.optional(),
+  limit: z.number().int().min(1).max(1e3).default(20),
+  offset: z.number().int().min(0).default(0)
+});
+z.object({
+  engineOverride: z.enum(["gemini", "claude", "codex", "ax-cli"]).optional(),
+  timeoutMs: z.number().int().min(5e3).max(3e5).optional(),
+  skipCache: z.boolean().default(false)
+});
+function isLoopPreventionError(error) {
+  return error instanceof LoopPreventionError;
+}
+
+// src/core/task-engine/loop-guard.ts
+init_esm_shims();
+var DEFAULT_BLOCKED_PATTERNS = [
+  // Prevent recursive hub pattern
+  /automatosx.*automatosx/
+];
+var CLIENT_NORMALIZATION_MAP = {
+  // Claude variants
+  "claude": "claude-code",
+  "claude-code": "claude-code",
+  "claudecode": "claude-code",
+  "anthropic": "claude-code",
+  // Gemini variants
+  "gemini": "gemini-cli",
+  "gemini-cli": "gemini-cli",
+  "geminicli": "gemini-cli",
+  "google": "gemini-cli",
+  // Codex variants
+  "codex": "codex-cli",
+  "codex-cli": "codex-cli",
+  "openai": "codex-cli",
+  "gpt": "codex-cli",
+  // ax-cli variants
+  "ax": "ax-cli",
+  "ax-cli": "ax-cli",
+  "axcli": "ax-cli"
+};
+var LoopGuard = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      maxDepth: config.maxDepth ?? 2,
+      maxChainLength: config.maxChainLength ?? 5,
+      blockSelfCalls: config.blockSelfCalls ?? true,
+      blockedPatterns: config.blockedPatterns ?? DEFAULT_BLOCKED_PATTERNS
+    };
+    if (this.config.maxDepth < 1 || this.config.maxDepth > 10) {
+      throw new Error("LoopGuard: maxDepth must be between 1 and 10");
+    }
+    if (this.config.maxChainLength < 2 || this.config.maxChainLength > 20) {
+      throw new Error("LoopGuard: maxChainLength must be between 2 and 20");
+    }
+  }
+  /**
+   * Validate that a task execution is allowed
+   *
+   * @param ctx - Current task context
+   * @param targetEngine - Engine to route the task to
+   * @throws {LoopPreventionError} If execution would cause a loop
+   */
+  validateExecution(ctx, targetEngine) {
+    const normalizedTarget = this.normalizeClient(targetEngine);
+    const projectedChain = [...ctx.callChain, "automatosx", normalizedTarget];
+    if (ctx.depth >= this.config.maxDepth) {
+      throw new LoopPreventionError(
+        `Maximum depth exceeded: current depth ${ctx.depth} >= limit ${this.config.maxDepth}`,
+        projectedChain,
+        "DEPTH_EXCEEDED"
+      );
+    }
+    if (this.config.blockSelfCalls) {
+      const engineInChain = ctx.callChain.some(
+        (entry) => this.normalizeClient(entry) === normalizedTarget
+      );
+      if (engineInChain) {
+        throw new LoopPreventionError(
+          `Circular call detected: ${normalizedTarget} already in chain [${ctx.callChain.join(" \u2192 ")}]`,
+          projectedChain,
+          "LOOP_DETECTED"
+        );
+      }
+    }
+    if (projectedChain.length > this.config.maxChainLength) {
+      throw new LoopPreventionError(
+        `Call chain too long: ${projectedChain.length} > ${this.config.maxChainLength}`,
+        projectedChain,
+        "CHAIN_TOO_LONG"
+      );
+    }
+    const chainString = projectedChain.join("\u2192");
+    for (const pattern of this.config.blockedPatterns) {
+      if (pattern.test(chainString)) {
+        throw new LoopPreventionError(
+          `Blocked pattern matched: ${chainString} matches ${pattern.toString()}`,
+          projectedChain,
+          "BLOCKED_PATTERN"
+        );
+      }
+    }
+  }
+  /**
+   * Create a new task context for an incoming request
+   *
+   * @param originClient - The client that initiated the request
+   * @param taskId - Optional task ID (will be set later if not provided)
+   * @returns New task context
+   */
+  createContext(originClient, taskId = "") {
+    const normalized = this.normalizeClient(originClient);
+    return {
+      taskId,
+      originClient: normalized,
+      callChain: [normalized],
+      depth: 0,
+      maxDepth: this.config.maxDepth,
+      createdAt: Date.now()
+    };
+  }
+  /**
+   * Extend a task context for a nested call
+   *
+   * @param ctx - Current task context
+   * @param engine - Engine being called
+   * @returns Extended task context
+   */
+  extendContext(ctx, engine) {
+    const normalizedEngine = this.normalizeClient(engine);
+    return {
+      ...ctx,
+      callChain: [...ctx.callChain, "automatosx", normalizedEngine],
+      depth: ctx.depth + 1,
+      createdAt: Date.now()
+    };
+  }
+  /**
+   * Merge an incoming context with the current context
+   * Used when a task already has context from a previous hop
+   *
+   * @param incomingCtx - Context from incoming request
+   * @param currentOrigin - Current origin (automatosx)
+   * @returns Merged context
+   */
+  mergeContext(incomingCtx, currentOrigin = "automatosx") {
+    const callChain = incomingCtx.callChain ?? [];
+    const originClient = incomingCtx.originClient ?? "unknown";
+    const mergedChain = callChain.length > 0 ? [...callChain, currentOrigin] : [originClient, currentOrigin];
+    return {
+      taskId: incomingCtx.taskId ?? "",
+      originClient: this.normalizeClient(originClient),
+      callChain: mergedChain,
+      depth: (incomingCtx.depth ?? 0) + 1,
+      maxDepth: this.config.maxDepth,
+      createdAt: Date.now()
+    };
+  }
+  /**
+   * Get a human-readable representation of the call chain
+   *
+   * @param ctx - Task context
+   * @returns Formatted call chain string
+   */
+  getCallChainString(ctx) {
+    return ctx.callChain.join(" \u2192 ");
+  }
+  /**
+   * Check if a context is valid (not expired or corrupted)
+   *
+   * @param ctx - Task context to validate
+   * @returns true if context is valid
+   */
+  isValidContext(ctx) {
+    if (!ctx || typeof ctx !== "object") {
+      return false;
+    }
+    const context = ctx;
+    return typeof context.taskId === "string" && typeof context.originClient === "string" && Array.isArray(context.callChain) && context.callChain.every((item) => typeof item === "string") && typeof context.depth === "number" && Number.isInteger(context.depth) && context.depth >= 0 && typeof context.maxDepth === "number" && typeof context.createdAt === "number";
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Normalize client name to standard format
+   *
+   * IMPORTANT: Unknown engines are preserved as-is (normalized formatting only)
+   * to prevent false-positive loop detection when two different unknown engines
+   * would both map to 'unknown' and trigger a circular call error.
+   */
+  normalizeClient(client) {
+    if (!client || typeof client !== "string") {
+      return "unknown";
+    }
+    const normalized = client.toLowerCase().trim().replace(/[\s-_]+/g, "-");
+    if (CLIENT_NORMALIZATION_MAP[normalized]) {
+      return CLIENT_NORMALIZATION_MAP[normalized];
+    }
+    return normalized;
+  }
+};
+function createLoopGuard(config) {
+  return new LoopGuard(config);
+}
+
+// src/core/task-engine/compression.ts
+init_esm_shims();
+var DEFAULT_COMPRESSION_LEVEL = 6;
+var MIN_COMPRESSION_THRESHOLD = 4096;
+function decompressPayload(compressed) {
+  try {
+    const decompressed = gunzipSync(compressed);
+    const json = decompressed.toString("utf-8");
+    return JSON.parse(json);
+  } catch (error) {
+    throw new TaskEngineError(
+      `Failed to decompress payload: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "COMPRESSION_ERROR",
+      { originalError: error }
+    );
+  }
+}
+function compressWithInfo(payload, options = {}) {
+  const level = options.level ?? DEFAULT_COMPRESSION_LEVEL;
+  const minThreshold = options.minThreshold ?? MIN_COMPRESSION_THRESHOLD;
+  try {
+    const json = JSON.stringify(payload);
+    const originalBuffer = Buffer.from(json, "utf-8");
+    const originalSize = originalBuffer.length;
+    if (originalSize < minThreshold) {
+      return {
+        data: originalBuffer,
+        originalSize,
+        compressedSize: originalSize,
+        ratio: 1,
+        compressed: false
+      };
+    }
+    const compressedBuffer = gzipSync(originalBuffer, {
+      level: Math.min(Math.max(level, 1), 9)
+    });
+    const compressedSize = compressedBuffer.length;
+    if (compressedSize >= originalSize) {
+      return {
+        data: originalBuffer,
+        originalSize,
+        compressedSize: originalSize,
+        ratio: 1,
+        compressed: false
+      };
+    }
+    return {
+      data: compressedBuffer,
+      originalSize,
+      compressedSize,
+      ratio: originalSize / compressedSize,
+      compressed: true
+    };
+  } catch (error) {
+    throw new TaskEngineError(
+      `Failed to compress payload: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "COMPRESSION_ERROR",
+      { originalError: error }
+    );
+  }
+}
+
+// src/core/task-engine/store.ts
+init_esm_shims();
+init_factory();
+init_logger();
+var DEFAULT_CONFIG3 = {
+  dbPath: ".automatosx/tasks/tasks.db",
+  maxPayloadBytes: 1024 * 1024,
+  // 1MB
+  compressionEnabled: true,
+  compressionLevel: 6,
+  defaultTtlHours: 24,
+  maxTtlHours: 168,
+  // 7 days
+  busyTimeout: 5e3
+};
+var SQL = {
+  CREATE_TABLE: `
+    CREATE TABLE IF NOT EXISTS task_store (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL CHECK (type IN ('web_search', 'code_review', 'code_generation', 'analysis', 'custom')),
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'completed', 'failed', 'expired')),
+      engine TEXT CHECK (engine IN ('gemini', 'claude', 'codex', 'ax-cli', NULL)),
+      priority INTEGER NOT NULL DEFAULT 5 CHECK (priority BETWEEN 1 AND 10),
+
+      payload_compressed BLOB NOT NULL,
+      payload_size_bytes INTEGER NOT NULL,
+      payload_hash TEXT NOT NULL,
+      is_compressed INTEGER NOT NULL DEFAULT 1,
+
+      result_compressed BLOB,
+      result_size_bytes INTEGER,
+      result_is_compressed INTEGER,
+
+      origin_client TEXT NOT NULL,
+      call_chain TEXT NOT NULL,
+      depth INTEGER NOT NULL DEFAULT 0,
+
+      created_at INTEGER NOT NULL,
+      started_at INTEGER,
+      completed_at INTEGER,
+      expires_at INTEGER NOT NULL,
+
+      duration_ms INTEGER,
+      tokens_prompt INTEGER,
+      tokens_completion INTEGER,
+      retry_count INTEGER NOT NULL DEFAULT 0,
+
+      error_code TEXT,
+      error_message TEXT
+    )
+  `,
+  CREATE_INDEXES: `
+    CREATE INDEX IF NOT EXISTS idx_task_status ON task_store(status);
+    CREATE INDEX IF NOT EXISTS idx_task_status_priority ON task_store(status, priority DESC);
+    CREATE INDEX IF NOT EXISTS idx_task_expires ON task_store(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_task_engine ON task_store(engine);
+    CREATE INDEX IF NOT EXISTS idx_task_created ON task_store(created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_task_payload_hash ON task_store(payload_hash);
+    CREATE INDEX IF NOT EXISTS idx_task_origin ON task_store(origin_client);
+  `,
+  INSERT_TASK: `
+    INSERT INTO task_store (
+      id, type, status, engine, priority,
+      payload_compressed, payload_size_bytes, payload_hash, is_compressed,
+      origin_client, call_chain, depth,
+      created_at, expires_at
+    ) VALUES (
+      :id, :type, :status, :engine, :priority,
+      :payload_compressed, :payload_size_bytes, :payload_hash, :is_compressed,
+      :origin_client, :call_chain, :depth,
+      :created_at, :expires_at
+    )
+  `,
+  GET_BY_ID: `
+    SELECT * FROM task_store WHERE id = ?
+  `,
+  UPDATE_STATUS: `
+    UPDATE task_store SET
+      status = :status,
+      started_at = COALESCE(:started_at, started_at),
+      completed_at = COALESCE(:completed_at, completed_at),
+      error_code = COALESCE(:error_code, error_code),
+      error_message = COALESCE(:error_message, error_message)
+    WHERE id = :id
+  `,
+  UPDATE_RESULT: `
+    UPDATE task_store SET
+      status = 'completed',
+      result_compressed = :result_compressed,
+      result_size_bytes = :result_size_bytes,
+      result_is_compressed = :result_is_compressed,
+      completed_at = :completed_at,
+      duration_ms = :duration_ms,
+      tokens_prompt = :tokens_prompt,
+      tokens_completion = :tokens_completion
+    WHERE id = :id
+  `,
+  UPDATE_FAILED: `
+    UPDATE task_store SET
+      status = 'failed',
+      completed_at = :completed_at,
+      duration_ms = :duration_ms,
+      error_code = :error_code,
+      error_message = :error_message,
+      retry_count = retry_count + 1
+    WHERE id = :id
+  `,
+  INCREMENT_RETRY: `
+    UPDATE task_store SET retry_count = retry_count + 1 WHERE id = ?
+  `,
+  DELETE_TASK: `
+    DELETE FROM task_store WHERE id = ?
+  `,
+  CLEANUP_EXPIRED: `
+    DELETE FROM task_store WHERE expires_at < ? AND status NOT IN ('running')
+  `,
+  CLEANUP_ZOMBIE_RUNNING: `
+    UPDATE task_store SET
+      status = 'failed',
+      completed_at = :completed_at,
+      error_code = 'ZOMBIE_TASK',
+      error_message = 'Task was stuck in running state past expiry'
+    WHERE status = 'running' AND expires_at < :now
+  `,
+  COUNT_BY_STATUS: `
+    SELECT status, COUNT(*) as count FROM task_store GROUP BY status
+  `,
+  FIND_BY_HASH: `
+    SELECT id FROM task_store WHERE payload_hash = ? AND status = 'completed' LIMIT 1
+  `
+};
+var TaskStore = class {
+  db;
+  config;
+  closed = false;
+  // Prepared statements
+  stmtInsert;
+  stmtGetById;
+  stmtUpdateStatus;
+  stmtUpdateResult;
+  stmtUpdateFailed;
+  stmtIncrementRetry;
+  stmtDelete;
+  stmtCleanup;
+  stmtCleanupZombies;
+  stmtCountByStatus;
+  stmtFindByHash;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.db = DatabaseFactory.create(this.config.dbPath, {
+      busyTimeout: this.config.busyTimeout,
+      enableWal: true
+    });
+    this.initializeSchema();
+    this.prepareStatements();
+    logger.debug("TaskStore initialized", {
+      dbPath: this.config.dbPath,
+      maxPayloadBytes: this.config.maxPayloadBytes,
+      compressionEnabled: this.config.compressionEnabled
+    });
+  }
+  /**
+   * Create a new task
+   */
+  createTask(input) {
+    this.ensureOpen();
+    const validated = CreateTaskInputSchema.parse(input);
+    const payloadJson = JSON.stringify(validated.payload);
+    const payloadSize = Buffer.byteLength(payloadJson, "utf-8");
+    if (payloadSize > this.config.maxPayloadBytes) {
+      throw new TaskEngineError(
+        `Payload size ${payloadSize} exceeds limit ${this.config.maxPayloadBytes}`,
+        "PAYLOAD_TOO_LARGE",
+        { payloadSize, limit: this.config.maxPayloadBytes }
+      );
+    }
+    let payloadBuffer;
+    let isCompressed;
+    let compressionRatio;
+    if (this.config.compressionEnabled) {
+      const result = compressWithInfo(validated.payload, {
+        level: this.config.compressionLevel
+      });
+      payloadBuffer = result.data;
+      isCompressed = result.compressed;
+      compressionRatio = result.ratio;
+    } else {
+      payloadBuffer = Buffer.from(payloadJson, "utf-8");
+      isCompressed = false;
+      compressionRatio = 1;
+    }
+    const taskId = this.generateTaskId();
+    const payloadHash = this.hashPayload(payloadJson);
+    const now = Date.now();
+    const ttlHours = Math.min(
+      validated.ttlHours ?? this.config.defaultTtlHours,
+      this.config.maxTtlHours
+    );
+    const expiresAt = now + ttlHours * 60 * 60 * 1e3;
+    const estimatedEngine = validated.engine === "auto" ? this.estimateEngine(validated.type) : validated.engine;
+    try {
+      this.stmtInsert.run({
+        id: taskId,
+        type: validated.type,
+        status: "pending",
+        engine: validated.engine === "auto" ? null : validated.engine,
+        priority: validated.priority ?? 5,
+        payload_compressed: payloadBuffer,
+        payload_size_bytes: payloadSize,
+        payload_hash: payloadHash,
+        is_compressed: isCompressed ? 1 : 0,
+        origin_client: validated.context?.originClient ?? "unknown",
+        call_chain: JSON.stringify(validated.context?.callChain ?? []),
+        depth: validated.context?.depth ?? 0,
+        created_at: now,
+        expires_at: expiresAt
+      });
+    } catch (error) {
+      throw new TaskEngineError(
+        `Failed to create task: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "STORE_ERROR",
+        { originalError: error }
+      );
+    }
+    logger.debug("Task created", {
+      taskId,
+      type: validated.type,
+      payloadSize,
+      compressedSize: payloadBuffer.length,
+      compressionRatio: compressionRatio.toFixed(2)
+    });
+    return {
+      id: taskId,
+      status: "pending",
+      estimatedEngine: estimatedEngine ?? null,
+      expiresAt,
+      payloadSize,
+      compressionRatio
+    };
+  }
+  /**
+   * Get a task by ID
+   */
+  getTask(taskId) {
+    this.ensureOpen();
+    const row = this.stmtGetById.get(taskId);
+    if (!row) {
+      return null;
+    }
+    return this.rowToTask(row);
+  }
+  /**
+   * Update task status
+   */
+  updateTaskStatus(taskId, status, error) {
+    this.ensureOpen();
+    const now = Date.now();
+    const params = {
+      id: taskId,
+      status,
+      started_at: status === "running" ? now : null,
+      completed_at: status === "completed" || status === "failed" ? now : null,
+      error_code: error?.code ?? null,
+      error_message: error?.message ?? null
+    };
+    const result = this.stmtUpdateStatus.run(params);
+    if (result.changes === 0) {
+      throw new TaskEngineError(
+        `Task not found: ${taskId}`,
+        "TASK_NOT_FOUND"
+      );
+    }
+    logger.debug("Task status updated", { taskId, status });
+  }
+  /**
+   * Update task with successful result
+   */
+  updateTaskResult(taskId, result, metrics) {
+    this.ensureOpen();
+    const now = Date.now();
+    const resultJson = JSON.stringify(result);
+    const resultSize = Buffer.byteLength(resultJson, "utf-8");
+    let resultBuffer;
+    let resultIsCompressed;
+    if (this.config.compressionEnabled) {
+      const compressed = compressWithInfo(result, {
+        level: this.config.compressionLevel
+      });
+      resultBuffer = compressed.data;
+      resultIsCompressed = compressed.compressed;
+    } else {
+      resultBuffer = Buffer.from(resultJson, "utf-8");
+      resultIsCompressed = false;
+    }
+    const dbResult = this.stmtUpdateResult.run({
+      id: taskId,
+      result_compressed: resultBuffer,
+      result_size_bytes: resultSize,
+      result_is_compressed: resultIsCompressed ? 1 : 0,
+      completed_at: now,
+      duration_ms: metrics.durationMs ?? null,
+      tokens_prompt: metrics.tokensPrompt ?? null,
+      tokens_completion: metrics.tokensCompletion ?? null
+    });
+    if (dbResult.changes === 0) {
+      throw new TaskEngineError(
+        `Task not found: ${taskId}`,
+        "TASK_NOT_FOUND"
+      );
+    }
+    logger.debug("Task result updated", {
+      taskId,
+      resultSize,
+      durationMs: metrics.durationMs
+    });
+  }
+  /**
+   * Update task with failure
+   */
+  updateTaskFailed(taskId, error, durationMs) {
+    this.ensureOpen();
+    const now = Date.now();
+    const result = this.stmtUpdateFailed.run({
+      id: taskId,
+      completed_at: now,
+      duration_ms: durationMs ?? null,
+      error_code: error.code,
+      error_message: error.message
+    });
+    if (result.changes === 0) {
+      throw new TaskEngineError(
+        `Task not found: ${taskId}`,
+        "TASK_NOT_FOUND"
+      );
+    }
+    logger.debug("Task marked as failed", { taskId, error: error.code });
+  }
+  /**
+   * Increment retry count
+   */
+  incrementRetry(taskId) {
+    this.ensureOpen();
+    this.stmtIncrementRetry.run(taskId);
+  }
+  /**
+   * Delete a task
+   */
+  deleteTask(taskId) {
+    this.ensureOpen();
+    const result = this.stmtDelete.run(taskId);
+    const deleted = result.changes > 0;
+    if (deleted) {
+      logger.debug("Task deleted", { taskId });
+    }
+    return deleted;
+  }
+  /**
+   * List tasks with optional filtering
+   */
+  listTasks(filter = {}) {
+    this.ensureOpen();
+    const validated = TaskFilterSchema.parse(filter);
+    const conditions = ["1=1"];
+    const params = {};
+    if (validated.status) {
+      conditions.push("status = :status");
+      params.status = validated.status;
+    }
+    if (validated.engine) {
+      conditions.push("engine = :engine");
+      params.engine = validated.engine;
+    }
+    if (validated.type) {
+      conditions.push("type = :type");
+      params.type = validated.type;
+    }
+    if (validated.originClient) {
+      conditions.push("origin_client = :origin_client");
+      params.origin_client = validated.originClient;
+    }
+    const query = `
+      SELECT * FROM task_store
+      WHERE ${conditions.join(" AND ")}
+      ORDER BY priority DESC, created_at ASC
+      LIMIT :limit OFFSET :offset
+    `;
+    params.limit = validated.limit ?? 20;
+    params.offset = validated.offset ?? 0;
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(params);
+    return rows.map((row) => this.rowToTask(row));
+  }
+  /**
+   * Count tasks by status
+   */
+  countByStatus() {
+    this.ensureOpen();
+    const rows = this.stmtCountByStatus.all();
+    const counts = {
+      pending: 0,
+      running: 0,
+      completed: 0,
+      failed: 0,
+      expired: 0
+    };
+    for (const row of rows) {
+      counts[row.status] = row.count;
+    }
+    return counts;
+  }
+  /**
+   * Count tasks matching filter (for pagination)
+   */
+  countTasks(filter = {}) {
+    this.ensureOpen();
+    const validated = TaskFilterSchema.parse(filter);
+    const conditions = ["1=1"];
+    const params = {};
+    if (validated.status) {
+      conditions.push("status = :status");
+      params.status = validated.status;
+    }
+    if (validated.engine) {
+      conditions.push("engine = :engine");
+      params.engine = validated.engine;
+    }
+    if (validated.type) {
+      conditions.push("type = :type");
+      params.type = validated.type;
+    }
+    if (validated.originClient) {
+      conditions.push("origin_client = :origin_client");
+      params.origin_client = validated.originClient;
+    }
+    const query = `SELECT COUNT(*) as count FROM task_store WHERE ${conditions.join(" AND ")}`;
+    const stmt = this.db.prepare(query);
+    const row = stmt.get(params);
+    return row.count;
+  }
+  /**
+   * Find a completed task with the same payload (for caching)
+   */
+  findByPayloadHash(payloadHash) {
+    this.ensureOpen();
+    const row = this.stmtFindByHash.get(payloadHash);
+    return row?.id ?? null;
+  }
+  /**
+   * Cleanup expired tasks
+   */
+  cleanupExpired() {
+    this.ensureOpen();
+    const now = Date.now();
+    const result = this.stmtCleanup.run(now);
+    if (result.changes > 0) {
+      logger.debug("Expired tasks cleaned up", { count: result.changes });
+    }
+    return result.changes;
+  }
+  /**
+   * Mark zombie running tasks as failed.
+   * These are tasks that have been in 'running' state past their expiry time,
+   * likely due to process crashes or other failures.
+   */
+  cleanupZombieRunning() {
+    this.ensureOpen();
+    const now = Date.now();
+    const result = this.stmtCleanupZombies.run({
+      now,
+      completed_at: now
+    });
+    if (result.changes > 0) {
+      logger.warn("Zombie running tasks marked as failed", { count: result.changes });
+    }
+    return result.changes;
+  }
+  /**
+   * Full cleanup: handles both expired non-running tasks and zombie running tasks.
+   * Call this periodically to prevent resource leaks.
+   */
+  cleanupAll() {
+    const zombies = this.cleanupZombieRunning();
+    const expired = this.cleanupExpired();
+    return { expired, zombies };
+  }
+  /**
+   * Get store statistics
+   */
+  getStats() {
+    this.ensureOpen();
+    const counts = this.countByStatus();
+    const totalTasks = Object.values(counts).reduce((a, b) => a + b, 0);
+    let dbSizeBytes = 0;
+    try {
+      const pageCount = this.db.pragma("page_count", { simple: true });
+      const pageSize = this.db.pragma("page_size", { simple: true });
+      dbSizeBytes = pageCount * pageSize;
+    } catch {
+    }
+    return {
+      totalTasks,
+      byStatus: counts,
+      dbSizeBytes
+    };
+  }
+  /**
+   * Close the store
+   */
+  close() {
+    if (this.closed) return;
+    DatabaseFactory.close(this.db);
+    this.closed = true;
+    logger.debug("TaskStore closed");
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  initializeSchema() {
+    this.db.exec(SQL.CREATE_TABLE);
+    const indexStatements = SQL.CREATE_INDEXES.split(";").filter((s) => s.trim());
+    for (const stmt of indexStatements) {
+      this.db.exec(stmt);
+    }
+  }
+  prepareStatements() {
+    this.stmtInsert = this.db.prepare(SQL.INSERT_TASK);
+    this.stmtGetById = this.db.prepare(SQL.GET_BY_ID);
+    this.stmtUpdateStatus = this.db.prepare(SQL.UPDATE_STATUS);
+    this.stmtUpdateResult = this.db.prepare(SQL.UPDATE_RESULT);
+    this.stmtUpdateFailed = this.db.prepare(SQL.UPDATE_FAILED);
+    this.stmtIncrementRetry = this.db.prepare(SQL.INCREMENT_RETRY);
+    this.stmtDelete = this.db.prepare(SQL.DELETE_TASK);
+    this.stmtCleanup = this.db.prepare(SQL.CLEANUP_EXPIRED);
+    this.stmtCleanupZombies = this.db.prepare(SQL.CLEANUP_ZOMBIE_RUNNING);
+    this.stmtCountByStatus = this.db.prepare(SQL.COUNT_BY_STATUS);
+    this.stmtFindByHash = this.db.prepare(SQL.FIND_BY_HASH);
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new TaskEngineError("TaskStore is closed", "STORE_ERROR");
+    }
+  }
+  generateTaskId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(4).toString("hex");
+    return `task_${timestamp}${random}`;
+  }
+  hashPayload(json) {
+    return createHash("sha256").update(json).digest("hex").substring(0, 16);
+  }
+  estimateEngine(type) {
+    switch (type) {
+      case "web_search":
+        return "gemini";
+      // Gemini is good for web search
+      case "code_review":
+      case "code_generation":
+        return "claude";
+      // Claude is good for code
+      case "analysis":
+        return "claude";
+      // Claude is good for analysis
+      case "custom":
+      default:
+        return "auto";
+    }
+  }
+  rowToTask(row) {
+    let payload;
+    try {
+      if (row.is_compressed) {
+        payload = decompressPayload(row.payload_compressed);
+      } else {
+        payload = JSON.parse(row.payload_compressed.toString("utf-8"));
+      }
+    } catch (error) {
+      logger.error("Failed to decompress task payload", {
+        taskId: row.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new TaskEngineError(
+        `Failed to decompress task payload for task ${row.id}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "STORE_ERROR",
+        { taskId: row.id, originalError: error }
+      );
+    }
+    let result = null;
+    if (row.result_compressed) {
+      try {
+        if (row.result_is_compressed) {
+          result = decompressPayload(row.result_compressed);
+        } else {
+          result = JSON.parse(row.result_compressed.toString("utf-8"));
+        }
+      } catch (error) {
+        logger.warn("Failed to decompress task result, returning null", {
+          taskId: row.id,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        result = null;
+      }
+    }
+    return {
+      id: row.id,
+      type: row.type,
+      status: row.status,
+      engine: row.engine,
+      priority: row.priority,
+      payload,
+      payloadSize: row.payload_size_bytes,
+      result,
+      context: {
+        originClient: row.origin_client,
+        callChain: JSON.parse(row.call_chain),
+        depth: row.depth
+      },
+      createdAt: row.created_at,
+      startedAt: row.started_at,
+      completedAt: row.completed_at,
+      expiresAt: row.expires_at,
+      metrics: row.duration_ms != null ? {
+        durationMs: row.duration_ms,
+        tokensPrompt: row.tokens_prompt,
+        tokensCompletion: row.tokens_completion
+      } : null,
+      error: row.error_code ? {
+        code: row.error_code,
+        message: row.error_message ?? ""
+      } : null,
+      retryCount: row.retry_count
+    };
+  }
+};
+function createTaskStore(config) {
+  return new TaskStore(config);
+}
+
+// src/core/task-engine/engine.ts
+init_esm_shims();
+init_logger();
+var DEFAULT_CONFIG4 = {
+  store: {},
+  loopGuard: {},
+  maxConcurrent: 50,
+  // Phase 5: Increased from 36 to 50
+  defaultTimeoutMs: 12e4,
+  maxRetries: 3,
+  retryDelayMs: 1e3,
+  cacheEnabled: true,
+  cacheTtlMs: 36e5
+  // 1 hour
+};
+var TaskEngine = class extends EventEmitter {
+  config;
+  loopGuard;
+  store;
+  runningTasks = /* @__PURE__ */ new Map();
+  closed = false;
+  // Statistics
+  stats = {
+    totalCreated: 0,
+    completed: 0,
+    failed: 0,
+    expired: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    totalDurationMs: 0
+  };
+  constructor(config = {}) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG4,
+      ...config,
+      store: { ...DEFAULT_CONFIG4.store, ...config.store },
+      loopGuard: { ...DEFAULT_CONFIG4.loopGuard, ...config.loopGuard }
+    };
+    this.loopGuard = createLoopGuard(this.config.loopGuard);
+    this.store = createTaskStore(this.config.store);
+    logger.info("TaskEngine initialized", {
+      maxConcurrent: this.config.maxConcurrent,
+      defaultTimeoutMs: this.config.defaultTimeoutMs,
+      cacheEnabled: this.config.cacheEnabled
+    });
+  }
+  // ============================================================================
+  // Public API
+  // ============================================================================
+  /**
+   * Create a new task
+   */
+  async createTask(input) {
+    this.ensureOpen();
+    try {
+      const result = this.store.createTask(input);
+      this.stats.totalCreated++;
+      this.emit("task:created", result);
+      logger.debug("Task created via engine", { taskId: result.id });
+      return result;
+    } catch (error) {
+      if (error instanceof TaskEngineError) {
+        throw error;
+      }
+      throw new TaskEngineError(
+        `Failed to create task: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "STORE_ERROR",
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Run a task
+   */
+  async runTask(taskId, options = {}) {
+    this.ensureOpen();
+    if (this.runningTasks.size >= this.config.maxConcurrent) {
+      throw new TaskEngineError(
+        `Maximum concurrent tasks reached: ${this.config.maxConcurrent}`,
+        "EXECUTION_FAILED",
+        { runningCount: this.runningTasks.size, limit: this.config.maxConcurrent }
+      );
+    }
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      throw new TaskEngineError(`Task not found: ${taskId}`, "TASK_NOT_FOUND");
+    }
+    if (task.status === "running") {
+      throw new TaskEngineError(
+        `Task is already running: ${taskId}`,
+        "TASK_ALREADY_RUNNING"
+      );
+    }
+    if (task.status === "completed") {
+      if (task.result) {
+        this.stats.cacheHits++;
+        return {
+          taskId,
+          status: "completed",
+          result: task.result,
+          engine: task.engine ?? "auto",
+          metrics: task.metrics,
+          error: null,
+          cacheHit: true
+        };
+      }
+    }
+    if (task.status === "expired") {
+      throw new TaskEngineError(`Task has expired: ${taskId}`, "TASK_EXPIRED");
+    }
+    if (Date.now() > task.expiresAt) {
+      this.store.updateTaskStatus(taskId, "expired");
+      throw new TaskEngineError(`Task has expired: ${taskId}`, "TASK_EXPIRED");
+    }
+    const targetEngine = options.engineOverride ?? task.engine ?? this.estimateEngine(task.type);
+    const loopContext = this.buildLoopContext(task, options.loopContext);
+    try {
+      this.loopGuard.validateExecution(loopContext, targetEngine);
+    } catch (error) {
+      if (isLoopPreventionError(error)) {
+        this.emit("loop:prevented", taskId, loopContext, targetEngine);
+        logger.warn("Loop prevented", {
+          taskId,
+          targetEngine,
+          callChain: error.callChain
+        });
+      }
+      throw error;
+    }
+    return this.executeTask(task, targetEngine, loopContext, options);
+  }
+  /**
+   * Get task result (without running)
+   */
+  getTaskResult(taskId) {
+    this.ensureOpen();
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      return null;
+    }
+    if (task.status !== "completed") {
+      return null;
+    }
+    return {
+      taskId,
+      status: "completed",
+      result: task.result,
+      engine: task.engine ?? "auto",
+      metrics: task.metrics,
+      error: null,
+      cacheHit: true
+    };
+  }
+  /**
+   * Get a task by ID
+   */
+  getTask(taskId) {
+    this.ensureOpen();
+    return this.store.getTask(taskId);
+  }
+  /**
+   * List tasks with pagination info
+   */
+  listTasks(filter) {
+    this.ensureOpen();
+    const tasks = this.store.listTasks(filter);
+    const total = this.store.countTasks(filter);
+    return { tasks, total };
+  }
+  /**
+   * Delete a task
+   */
+  deleteTask(taskId, force = false) {
+    this.ensureOpen();
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      return false;
+    }
+    if (task.status === "running" && !force) {
+      throw new TaskEngineError(
+        `Cannot delete running task: ${taskId}. Use force=true to override.`,
+        "TASK_ALREADY_RUNNING"
+      );
+    }
+    if (task.status === "running") {
+      const controller = this.runningTasks.get(taskId);
+      if (controller) {
+        controller.abort();
+        this.runningTasks.delete(taskId);
+      }
+    }
+    return this.store.deleteTask(taskId);
+  }
+  /**
+   * Get engine statistics
+   */
+  getStats() {
+    this.ensureOpen();
+    const storeStats = this.store.getStats();
+    const cacheTotal = this.stats.cacheHits + this.stats.cacheMisses;
+    return {
+      totalCreated: this.stats.totalCreated,
+      runningCount: this.runningTasks.size,
+      completedCount: storeStats.byStatus.completed,
+      failedCount: storeStats.byStatus.failed,
+      expiredCount: storeStats.byStatus.expired,
+      cache: {
+        hits: this.stats.cacheHits,
+        misses: this.stats.cacheMisses,
+        hitRate: cacheTotal > 0 ? this.stats.cacheHits / cacheTotal : 0
+      },
+      avgDurationMs: this.stats.completed > 0 ? this.stats.totalDurationMs / this.stats.completed : 0
+    };
+  }
+  /**
+   * Cleanup expired tasks
+   */
+  cleanupExpired() {
+    this.ensureOpen();
+    const cleaned = this.store.cleanupExpired();
+    this.stats.expired += cleaned;
+    return cleaned;
+  }
+  /**
+   * Shutdown the engine
+   */
+  async shutdown() {
+    if (this.closed) return;
+    logger.info("TaskEngine shutting down", {
+      runningTasks: this.runningTasks.size
+    });
+    for (const [taskId, controller] of this.runningTasks) {
+      controller.abort();
+      logger.debug("Cancelled running task", { taskId });
+    }
+    this.runningTasks.clear();
+    this.store.close();
+    this.closed = true;
+    logger.info("TaskEngine shutdown complete");
+  }
+  /**
+   * Check if engine is healthy
+   */
+  isHealthy() {
+    return !this.closed && this.runningTasks.size < this.config.maxConcurrent;
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  async executeTask(task, targetEngine, context, options) {
+    const taskId = task.id;
+    const abortController = new AbortController();
+    const startTime = Date.now();
+    this.runningTasks.set(taskId, abortController);
+    this.store.updateTaskStatus(taskId, "running");
+    this.emit("task:started", taskId, targetEngine);
+    const timeoutMs = options.timeoutMs ?? this.config.defaultTimeoutMs;
+    const timeoutId = setTimeout(() => {
+      abortController.abort();
+    }, timeoutMs);
+    try {
+      const result = await this.executeWithRetry(
+        task,
+        targetEngine,
+        context,
+        abortController.signal
+      );
+      const durationMs = Date.now() - startTime;
+      this.store.updateTaskResult(taskId, result, {
+        durationMs,
+        tokensPrompt: null,
+        tokensCompletion: null
+      });
+      this.stats.completed++;
+      this.stats.cacheMisses++;
+      this.stats.totalDurationMs += durationMs;
+      const taskResult = {
+        taskId,
+        status: "completed",
+        result,
+        engine: targetEngine,
+        metrics: { durationMs, tokensPrompt: null, tokensCompletion: null },
+        error: null,
+        cacheHit: false
+      };
+      this.emit("task:completed", taskId, taskResult);
+      logger.debug("Task completed", { taskId, durationMs, engine: targetEngine });
+      return taskResult;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      if (abortController.signal.aborted) {
+        const taskError2 = { code: "TIMEOUT", message: `Task timed out after ${timeoutMs}ms` };
+        this.store.updateTaskFailed(taskId, taskError2, durationMs);
+        this.stats.failed++;
+        this.emit("task:failed", taskId, new TaskEngineError(taskError2.message, "EXECUTION_TIMEOUT"));
+        return {
+          taskId,
+          status: "failed",
+          result: null,
+          engine: targetEngine,
+          metrics: { durationMs, tokensPrompt: null, tokensCompletion: null },
+          error: taskError2,
+          cacheHit: false
+        };
+      }
+      const taskError = {
+        code: error instanceof TaskEngineError ? error.code : "EXECUTION_FAILED",
+        message: errorObj.message
+      };
+      this.store.updateTaskFailed(taskId, taskError, durationMs);
+      this.stats.failed++;
+      this.emit("task:failed", taskId, errorObj);
+      logger.error("Task failed", { taskId, error: errorObj.message, durationMs });
+      return {
+        taskId,
+        status: "failed",
+        result: null,
+        engine: targetEngine,
+        metrics: { durationMs, tokensPrompt: null, tokensCompletion: null },
+        error: taskError,
+        cacheHit: false
+      };
+    } finally {
+      clearTimeout(timeoutId);
+      this.runningTasks.delete(taskId);
+    }
+  }
+  async executeWithRetry(task, engine, context, signal) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      if (signal.aborted) {
+        throw new TaskEngineError("Task execution aborted", "EXECUTION_TIMEOUT");
+      }
+      try {
+        return await this.executeOnEngine(task, engine, context, signal);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (isLoopPreventionError(error)) {
+          throw error;
+        }
+        if (signal.aborted) {
+          throw error;
+        }
+        if (attempt < this.config.maxRetries && this.isRetryableError(error)) {
+          const delay = this.config.retryDelayMs * Math.pow(2, attempt);
+          this.store.incrementRetry(task.id);
+          this.emit("task:retry", task.id, attempt + 1, lastError);
+          logger.debug("Retrying task", {
+            taskId: task.id,
+            attempt: attempt + 1,
+            delay,
+            error: lastError.message
+          });
+          await this.sleep(delay, signal);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError ?? new TaskEngineError("Task execution failed", "EXECUTION_FAILED");
+  }
+  /**
+   * Execute task on target engine
+   *
+   * Phase 1: Simulated execution (returns mock result)
+   * Phase 2+: Will integrate with Router for actual execution
+   */
+  async executeOnEngine(task, engine, context, signal) {
+    logger.debug("Executing task on engine", {
+      taskId: task.id,
+      engine,
+      type: task.type,
+      callChain: context.callChain
+    });
+    await this.sleep(100, signal);
+    switch (task.type) {
+      case "web_search":
+        return {
+          query: task.payload.query ?? "unknown",
+          results: [
+            { title: "Result 1", url: "https://example.com/1", snippet: "Sample result 1" },
+            { title: "Result 2", url: "https://example.com/2", snippet: "Sample result 2" }
+          ],
+          engine,
+          timestamp: Date.now()
+        };
+      case "code_review":
+        return {
+          file: task.payload.file ?? "unknown.ts",
+          issues: [],
+          suggestions: ["Consider adding type annotations"],
+          engine,
+          timestamp: Date.now()
+        };
+      case "code_generation":
+        return {
+          prompt: task.payload.prompt ?? "",
+          code: "// Generated code placeholder",
+          language: task.payload.language ?? "typescript",
+          engine,
+          timestamp: Date.now()
+        };
+      case "analysis":
+        return {
+          input: task.payload.input ?? {},
+          analysis: "Analysis result placeholder",
+          confidence: 0.95,
+          engine,
+          timestamp: Date.now()
+        };
+      case "custom":
+      default:
+        return {
+          payload: task.payload,
+          result: "Custom task completed",
+          engine,
+          timestamp: Date.now()
+        };
+    }
+  }
+  buildLoopContext(task, incomingContext) {
+    if (incomingContext) {
+      return this.loopGuard.mergeContext(incomingContext);
+    }
+    return {
+      taskId: task.id,
+      originClient: task.context.originClient,
+      callChain: task.context.callChain.length > 0 ? task.context.callChain : [task.context.originClient],
+      depth: task.context.depth,
+      maxDepth: this.loopGuard.getConfig().maxDepth,
+      createdAt: task.createdAt
+    };
+  }
+  estimateEngine(type) {
+    switch (type) {
+      case "web_search":
+        return "gemini";
+      case "code_review":
+      case "code_generation":
+        return "claude";
+      case "analysis":
+        return "claude";
+      default:
+        return "claude";
+    }
+  }
+  isRetryableError(error) {
+    if (error instanceof TaskEngineError) {
+      const nonRetryable = [
+        "TASK_NOT_FOUND",
+        "TASK_EXPIRED",
+        "PAYLOAD_TOO_LARGE",
+        "LOOP_DETECTED",
+        "DEPTH_EXCEEDED",
+        "CHAIN_TOO_LONG",
+        "BLOCKED_PATTERN"
+      ];
+      return !nonRetryable.includes(error.code);
+    }
+    return true;
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new TaskEngineError("TaskEngine is closed", "EXECUTION_FAILED");
+    }
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve13, reject) => {
+      if (signal?.aborted) {
+        reject(new Error("Aborted"));
+        return;
+      }
+      const abortHandler = () => {
+        clearTimeout(timeoutId);
+        reject(new Error("Aborted"));
+      };
+      const timeoutId = setTimeout(() => {
+        signal?.removeEventListener("abort", abortHandler);
+        resolve13();
+      }, ms);
+      signal?.addEventListener("abort", abortHandler, { once: true });
+    });
+  }
+};
+var defaultTaskEngine = null;
+function getTaskEngine(config) {
+  if (!defaultTaskEngine) {
+    defaultTaskEngine = new TaskEngine(config);
+  }
+  return defaultTaskEngine;
+}
+
+// src/core/task-engine/cache.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/write-batcher.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/request-coalescer.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/rate-limiter.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/audit-logger.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/circuit-breaker.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/write-pool.ts
+init_esm_shims();
+init_logger();
+
+// src/core/task-engine/task-queue.ts
+init_esm_shims();
+init_logger();
+
+// src/mcp/tools/task/create-task.ts
+init_logger();
+function createCreateTaskHandler(deps) {
+  return async (input) => {
+    const startTime = Date.now();
+    logger.info("[create_task] Creating task", {
+      type: input.type,
+      engine: input.engine ?? "auto",
+      priority: input.priority ?? 5,
+      payloadSize: JSON.stringify(input.payload).length
+    });
+    try {
+      const taskEngine = getTaskEngine();
+      const session = deps.getSession();
+      const taskInput = {
+        type: input.type,
+        payload: input.payload,
+        engine: input.engine,
+        priority: input.priority,
+        ttlHours: input.ttl_hours,
+        context: session ? {
+          originClient: mapNormalizedProviderToOriginClient(session.normalizedProvider),
+          callChain: [mapNormalizedProviderToOriginClient(session.normalizedProvider)],
+          depth: 0
+        } : void 0
+      };
+      const result = await taskEngine.createTask(taskInput);
+      const output = {
+        task_id: result.id,
+        status: "pending",
+        estimated_engine: result.estimatedEngine,
+        expires_at: new Date(result.expiresAt).toISOString(),
+        payload_size_bytes: result.payloadSize,
+        compression_ratio: result.compressionRatio
+      };
+      logger.info("[create_task] Task created successfully", {
+        taskId: result.id,
+        estimatedEngine: result.estimatedEngine,
+        durationMs: Date.now() - startTime
+      });
+      return output;
+    } catch (error) {
+      logger.error("[create_task] Failed to create task", {
+        error: error instanceof Error ? error.message : String(error),
+        type: input.type
+      });
+      throw error;
+    }
+  };
+}
+function mapNormalizedProviderToOriginClient(provider) {
+  const mapping = {
+    "claude": "claude-code",
+    "gemini": "gemini-cli",
+    "codex": "codex-cli",
+    "ax-cli": "ax-cli",
+    "unknown": "unknown"
+  };
+  return mapping[provider] ?? "unknown";
+}
+var createTaskSchema = {
+  name: "create_task",
+  description: "Create a new task with payload for deferred execution. Returns task_id for later execution via run_task.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        enum: ["web_search", "code_review", "code_generation", "analysis", "custom"],
+        description: "Task type for routing optimization"
+      },
+      payload: {
+        type: "object",
+        description: "Task data (max 1MB after JSON serialization)"
+      },
+      engine: {
+        type: "string",
+        enum: ["auto", "gemini", "claude", "codex", "ax-cli"],
+        default: "auto",
+        description: "Target engine (auto = router decides)"
+      },
+      priority: {
+        type: "integer",
+        minimum: 1,
+        maximum: 10,
+        default: 5,
+        description: "Execution priority (1=lowest, 10=highest)"
+      },
+      ttl_hours: {
+        type: "integer",
+        minimum: 1,
+        maximum: 168,
+        default: 24,
+        description: "Task time-to-live in hours"
+      }
+    },
+    required: ["type", "payload"]
+  }
+};
+
+// src/mcp/tools/task/run-task.ts
+init_esm_shims();
+init_logger();
+function createRunTaskHandler(deps) {
+  return async (input) => {
+    const startTime = Date.now();
+    logger.info("[run_task] Executing task", {
+      taskId: input.task_id,
+      engineOverride: input.engine_override,
+      timeoutMs: input.timeout_ms,
+      skipCache: input.skip_cache
+    });
+    try {
+      const taskEngine = getTaskEngine();
+      const session = deps.getSession();
+      const options = {
+        engineOverride: input.engine_override,
+        timeoutMs: input.timeout_ms,
+        skipCache: input.skip_cache
+      };
+      const result = await taskEngine.runTask(input.task_id, options);
+      const output = {
+        task_id: result.taskId,
+        status: result.status,
+        result: result.result,
+        engine: result.engine,
+        metrics: {
+          duration_ms: result.metrics?.durationMs ?? 0,
+          tokens_prompt: result.metrics?.tokensPrompt ?? null,
+          tokens_completion: result.metrics?.tokensCompletion ?? null
+        },
+        cache_hit: result.cacheHit
+      };
+      if (result.error) {
+        output.error = {
+          code: result.error.code,
+          message: result.error.message
+        };
+      }
+      logger.info("[run_task] Task execution completed", {
+        taskId: result.taskId,
+        status: result.status,
+        engine: result.engine,
+        cacheHit: result.cacheHit,
+        durationMs: Date.now() - startTime
+      });
+      return output;
+    } catch (error) {
+      logger.error("[run_task] Failed to execute task", {
+        error: error instanceof Error ? error.message : String(error),
+        taskId: input.task_id
+      });
+      throw error;
+    }
+  };
+}
+var runTaskSchema = {
+  name: "run_task",
+  description: "Execute a previously created task and return results. Blocks until completion or timeout.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: {
+        type: "string",
+        description: "Task ID to execute"
+      },
+      engine_override: {
+        type: "string",
+        enum: ["gemini", "claude", "codex", "ax-cli"],
+        description: "Override the estimated engine"
+      },
+      timeout_ms: {
+        type: "integer",
+        minimum: 1e3,
+        maximum: 3e5,
+        default: 3e4,
+        description: "Custom timeout in milliseconds"
+      },
+      skip_cache: {
+        type: "boolean",
+        default: false,
+        description: "Skip cache and force re-execution"
+      }
+    },
+    required: ["task_id"]
+  }
+};
+
+// src/mcp/tools/task/get-task-result.ts
+init_esm_shims();
+init_logger();
+function createGetTaskResultHandler() {
+  return async (input) => {
+    logger.info("[get_task_result] Retrieving task", {
+      taskId: input.task_id,
+      includePayload: input.include_payload
+    });
+    try {
+      const taskEngine = getTaskEngine();
+      const task = taskEngine.getTask(input.task_id);
+      if (!task) {
+        throw new Error(`Task not found: ${input.task_id}`);
+      }
+      const output = {
+        task_id: task.id,
+        status: task.status,
+        type: task.type,
+        result: task.result,
+        engine: task.engine,
+        created_at: new Date(task.createdAt).toISOString(),
+        completed_at: task.completedAt ? new Date(task.completedAt).toISOString() : null,
+        expires_at: new Date(task.expiresAt).toISOString()
+      };
+      if (input.include_payload) {
+        output.payload = task.payload;
+      }
+      if (task.error) {
+        output.error = {
+          code: task.error.code,
+          message: task.error.message
+        };
+      }
+      logger.info("[get_task_result] Task retrieved", {
+        taskId: task.id,
+        status: task.status
+      });
+      return output;
+    } catch (error) {
+      logger.error("[get_task_result] Failed to retrieve task", {
+        error: error instanceof Error ? error.message : String(error),
+        taskId: input.task_id
+      });
+      throw error;
+    }
+  };
+}
+var getTaskResultSchema = {
+  name: "get_task_result",
+  description: "Retrieve the result of a task. Does not execute - use run_task for execution.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: {
+        type: "string",
+        description: "Task ID to retrieve"
+      },
+      include_payload: {
+        type: "boolean",
+        default: false,
+        description: "Include original payload in response"
+      }
+    },
+    required: ["task_id"]
+  }
+};
+
+// src/mcp/tools/task/list-tasks.ts
+init_esm_shims();
+init_logger();
+function createListTasksHandler() {
+  return async (input) => {
+    const limit = Math.min(input.limit ?? 20, 100);
+    const offset = input.offset ?? 0;
+    logger.info("[list_tasks] Listing tasks", {
+      status: input.status,
+      type: input.type,
+      engine: input.engine,
+      limit,
+      offset
+    });
+    try {
+      const taskEngine = getTaskEngine();
+      const filter = {
+        status: input.status,
+        type: input.type,
+        engine: input.engine,
+        limit,
+        offset
+      };
+      const result = taskEngine.listTasks(filter);
+      const tasks = result.tasks.map((task) => ({
+        task_id: task.id,
+        type: task.type,
+        status: task.status,
+        engine: task.engine,
+        priority: task.priority,
+        created_at: new Date(task.createdAt).toISOString(),
+        expires_at: new Date(task.expiresAt).toISOString(),
+        has_result: task.result !== null
+      }));
+      const output = {
+        tasks,
+        total: result.total,
+        offset,
+        limit,
+        has_more: offset + tasks.length < result.total
+      };
+      logger.info("[list_tasks] Tasks listed", {
+        returned: tasks.length,
+        total: result.total,
+        hasMore: output.has_more
+      });
+      return output;
+    } catch (error) {
+      logger.error("[list_tasks] Failed to list tasks", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  };
+}
+var listTasksSchema = {
+  name: "list_tasks",
+  description: "List tasks with optional filtering. Supports pagination.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      status: {
+        type: "string",
+        enum: ["pending", "running", "completed", "failed", "expired"],
+        description: "Filter by task status"
+      },
+      type: {
+        type: "string",
+        enum: ["web_search", "code_review", "code_generation", "analysis", "custom"],
+        description: "Filter by task type"
+      },
+      engine: {
+        type: "string",
+        enum: ["gemini", "claude", "codex", "ax-cli"],
+        description: "Filter by engine"
+      },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: 100,
+        default: 20,
+        description: "Maximum results to return"
+      },
+      offset: {
+        type: "integer",
+        minimum: 0,
+        default: 0,
+        description: "Offset for pagination"
+      }
+    },
+    required: []
+  }
+};
+
+// src/mcp/tools/task/delete-task.ts
+init_esm_shims();
+init_logger();
+function createDeleteTaskHandler() {
+  return async (input) => {
+    logger.info("[delete_task] Deleting task", {
+      taskId: input.task_id,
+      force: input.force
+    });
+    try {
+      const taskEngine = getTaskEngine();
+      const task = taskEngine.getTask(input.task_id);
+      if (!task) {
+        return {
+          task_id: input.task_id,
+          deleted: false,
+          previous_status: "unknown",
+          message: `Task not found: ${input.task_id}`
+        };
+      }
+      if (task.status === "running" && !input.force) {
+        return {
+          task_id: input.task_id,
+          deleted: false,
+          previous_status: task.status,
+          message: "Cannot delete running task. Use force=true to override."
+        };
+      }
+      const deleted = taskEngine.deleteTask(input.task_id);
+      const output = {
+        task_id: input.task_id,
+        deleted,
+        previous_status: task.status,
+        message: deleted ? `Task ${input.task_id} deleted successfully` : `Failed to delete task ${input.task_id}`
+      };
+      logger.info("[delete_task] Task deletion result", {
+        taskId: input.task_id,
+        deleted,
+        previousStatus: task.status
+      });
+      return output;
+    } catch (error) {
+      logger.error("[delete_task] Failed to delete task", {
+        error: error instanceof Error ? error.message : String(error),
+        taskId: input.task_id
+      });
+      throw error;
+    }
+  };
+}
+var deleteTaskSchema = {
+  name: "delete_task",
+  description: "Delete a task and its associated data. Cannot delete running tasks unless force=true.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: {
+        type: "string",
+        description: "Task ID to delete"
+      },
+      force: {
+        type: "boolean",
+        default: false,
+        description: "Force delete even if task is running"
+      }
+    },
+    required: ["task_id"]
+  }
+};
+
 // src/providers/mcp/pool-manager.ts
 init_esm_shims();
 init_logger();
@@ -27988,7 +29975,7 @@ var ConnectionTimeoutError = class extends McpClientError {
 };
 
 // src/providers/mcp/pool-manager.ts
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG6 = {
   maxConnectionsPerProvider: 2,
   idleTimeoutMs: 3e5,
   // 5 minutes
@@ -28009,7 +29996,7 @@ var McpClientPool = class extends EventEmitter {
   drainHandler;
   constructor(config = {}) {
     super();
-    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.config = { ...DEFAULT_CONFIG6, ...config };
     this.startHealthChecks();
     this.startIdleCleanup();
     this.drainHandler = () => this.drain();
@@ -29931,7 +31918,13 @@ var McpServer = class _McpServer {
           },
           required: ["agent", "task"]
         }
-      }
+      },
+      // v11.3.5: Task Engine tools
+      createTaskSchema,
+      runTaskSchema,
+      getTaskResultSchema,
+      listTasksSchema,
+      deleteTaskSchema
     ];
   }
   /**
@@ -30106,6 +32099,15 @@ var McpServer = class _McpServer {
       profileLoader: this.profileLoader,
       memoryManager: this.memoryManager
     }));
+    register("create_task", createCreateTaskHandler({
+      getSession: () => this.session
+    }));
+    register("run_task", createRunTaskHandler({
+      getSession: () => this.session
+    }));
+    register("get_task_result", createGetTaskResultHandler());
+    register("list_tasks", createListTasksHandler());
+    register("delete_task", createDeleteTaskHandler());
     logger.info("[MCP Server] Registered tools", {
       count: this.tools.size,
       tools: Array.from(this.tools.keys())
@@ -32408,9 +34410,9 @@ var ProgressIndicator = class {
 // src/cli/commands/memory.ts
 var DEFAULT_DB_PATH = ".automatosx/memory/memory.db";
 function getMemoryManager(dbPath) {
-  const path8 = dbPath || DEFAULT_DB_PATH;
+  const path9 = dbPath || DEFAULT_DB_PATH;
   return new LazyMemoryManager({
-    dbPath: resolve(path8),
+    dbPath: resolve(path9),
     maxEntries: 1e5,
     autoCleanup: false,
     trackAccess: true
@@ -35414,14 +37416,14 @@ var IterateClassifier = class _IterateClassifier {
    * **Phase 1 (Week 1)**: Skeleton only (no-op)
    * **Phase 2 (Week 2)**: Full implementation with YAML loading and validation
    */
-  async loadPatterns(path8) {
-    logger.debug("Loading pattern library", { path: path8 });
-    if (!existsSync(path8)) {
-      logger.warn("Pattern library file not found", { path: path8 });
+  async loadPatterns(path9) {
+    logger.debug("Loading pattern library", { path: path9 });
+    if (!existsSync(path9)) {
+      logger.warn("Pattern library file not found", { path: path9 });
       return;
     }
     try {
-      const fileContent = await readFile(path8, "utf-8");
+      const fileContent = await readFile(path9, "utf-8");
       const parsed = load(fileContent);
       if (!parsed || typeof parsed !== "object") {
         throw new Error("Invalid pattern library format: not an object");
@@ -35464,7 +37466,7 @@ var IterateClassifier = class _IterateClassifier {
       });
     } catch (error) {
       logger.error("Failed to load pattern library", {
-        path: path8,
+        path: path9,
         error: error.message
       });
       throw error;
@@ -35891,14 +37893,14 @@ var IterateAutoResponder = class {
    * **Phase 1 (Week 1)**: Skeleton only (no-op)
    * **Phase 3 (Week 3)**: Full implementation with YAML loading and validation
    */
-  async loadTemplates(path8) {
-    logger.debug("Loading template library", { path: path8 });
-    if (!existsSync(path8)) {
-      logger.warn("Template library file not found", { path: path8 });
+  async loadTemplates(path9) {
+    logger.debug("Loading template library", { path: path9 });
+    if (!existsSync(path9)) {
+      logger.warn("Template library file not found", { path: path9 });
       return;
     }
     try {
-      const fileContent = await readFile(path8, "utf-8");
+      const fileContent = await readFile(path9, "utf-8");
       const parsed = load(fileContent);
       if (!parsed || typeof parsed !== "object") {
         throw new Error("Invalid template library format: not an object");
@@ -35940,7 +37942,7 @@ var IterateAutoResponder = class {
       });
     } catch (error) {
       logger.error("Failed to load template library", {
-        path: path8,
+        path: path9,
         error: error.message
       });
       throw error;
@@ -40191,10 +42193,10 @@ async function getCurrentVersion() {
     return result.dependencies["@defai.digital/automatosx"]?.version || "unknown";
   } catch (error) {
     const { readFile: readFile24 } = await import('fs/promises');
-    const { dirname: dirname16, join: join52 } = await import('path');
+    const { dirname: dirname17, join: join52 } = await import('path');
     const { fileURLToPath: fileURLToPath5 } = await import('url');
     const __filename3 = fileURLToPath5(import.meta.url);
-    const __dirname4 = dirname16(__filename3);
+    const __dirname4 = dirname17(__filename3);
     const pkgPath = join52(__dirname4, "../../../package.json");
     const content = await readFile24(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
@@ -42265,8 +44267,8 @@ var ConfigManager = class {
    * @returns User configuration or empty object if not found
    */
   async readUserConfig() {
-    const path8 = getUserConfigPath();
-    return this.readConfig(path8, "user");
+    const path9 = getUserConfigPath();
+    return this.readConfig(path9, "user");
   }
   /**
    * Read project-level Gemini CLI configuration
@@ -42274,8 +44276,8 @@ var ConfigManager = class {
    * @returns Project configuration or empty object if not found
    */
   async readProjectConfig() {
-    const path8 = getProjectConfigPath();
-    return this.readConfig(path8, "project");
+    const path9 = getProjectConfigPath();
+    return this.readConfig(path9, "project");
   }
   /**
    * Read configuration from a specific path with caching
@@ -42285,7 +44287,7 @@ var ConfigManager = class {
    * @returns Configuration object
    * @private
    */
-  async readConfig(path8, scope) {
+  async readConfig(path9, scope) {
     const cached = this.cache.get(scope);
     if (cached && Date.now() - cached.timestamp < this.ttl) {
       return cached.data;
@@ -42296,13 +44298,13 @@ var ConfigManager = class {
     }
     const readOperation = (async () => {
       try {
-        const exists = await fileExists(path8);
+        const exists = await fileExists(path9);
         if (!exists) {
           const emptyConfig = {};
           this.cache.set(scope, { data: emptyConfig, timestamp: Date.now() });
           return emptyConfig;
         }
-        const config = await readJsonFile(path8);
+        const config = await readJsonFile(path9);
         this.cache.set(scope, { data: config, timestamp: Date.now() });
         return config;
       } catch (error) {
@@ -42311,8 +44313,8 @@ var ConfigManager = class {
         }
         throw new GeminiCLIError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          `Failed to read configuration from ${path8}`,
-          { path: path8, originalError: error }
+          `Failed to read configuration from ${path9}`,
+          { path: path9, originalError: error }
         );
       } finally {
         this.pendingReads.delete(scope);
@@ -42982,8 +44984,8 @@ var CommandTranslator = class {
         paths.push(getProjectCommandsPath());
       }
     }
-    for (const path8 of paths) {
-      const discovered = await this.scanDirectory(path8);
+    for (const path9 of paths) {
+      const discovered = await this.scanDirectory(path9);
       commands.push(...discovered);
     }
     return commands;
@@ -43024,8 +45026,8 @@ var CommandTranslator = class {
     const results = [];
     for (const name of commandNames) {
       try {
-        const path8 = await this.importCommand(name, outputDir, options);
-        results.push(path8);
+        const path9 = await this.importCommand(name, outputDir, options);
+        results.push(path9);
       } catch (error) {
         if (error instanceof GeminiCLIError) {
           console.error(`Failed to import ${name}: ${error.message}`);
@@ -44357,7 +46359,7 @@ var SpecSchemaValidator = class {
    * Convert Ajv error to ValidationIssue
    */
   convertAjvError(error) {
-    const path8 = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+    const path9 = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
     const keyword = error.keyword;
     let message = error.message || "Validation error";
     let suggestion;
@@ -44408,7 +46410,7 @@ var SpecSchemaValidator = class {
       ruleId: `SCHEMA-${keyword.toUpperCase()}`,
       severity: "error",
       message,
-      path: path8 || void 0,
+      path: path9 || void 0,
       suggestion
     };
   }
@@ -47227,10 +49229,10 @@ async function handleReset() {
 `));
 }
 async function handleTrace(workspacePath, argv) {
-  const { existsSync: existsSync27, readFileSync: readFileSync9, watchFile } = await import('fs');
+  const { existsSync: existsSync28, readFileSync: readFileSync9, watchFile } = await import('fs');
   const { join: join52 } = await import('path');
   const traceFile = join52(workspacePath, ".automatosx/logs/router.trace.jsonl");
-  if (!existsSync27(traceFile)) {
+  if (!existsSync28(traceFile)) {
     console.log(chalk5.yellow("\n\u26A0\uFE0F  No trace log found\n"));
     console.log(chalk5.gray(`Expected location: ${traceFile}
 `));
@@ -50138,13 +52140,13 @@ Time since last change: ${timeSinceLastChange}ms`
 init_logger();
 var flagManagerInstances = /* @__PURE__ */ new Map();
 function getFlagManager(workspacePath) {
-  const path8 = process.cwd();
-  if (!flagManagerInstances.has(path8)) {
-    const manager = new FeatureFlagManager(path8);
+  const path9 = process.cwd();
+  if (!flagManagerInstances.has(path9)) {
+    const manager = new FeatureFlagManager(path9);
     initializeFlags(manager);
-    flagManagerInstances.set(path8, manager);
+    flagManagerInstances.set(path9, manager);
   }
-  return flagManagerInstances.get(path8);
+  return flagManagerInstances.get(path9);
 }
 function initializeFlags(manager) {
   if (!manager.hasStorage()) {
@@ -50465,9 +52467,9 @@ var cliCommand = {
 // src/cli/commands/uninstall.ts
 init_esm_shims();
 init_logger();
-async function fileExists2(path8) {
+async function fileExists2(path9) {
   try {
-    await access$1(path8);
+    await access$1(path9);
     return true;
   } catch {
     return false;
@@ -51459,7 +53461,7 @@ var TodoInstructionProvider = class {
 };
 function computeTodoHash(todos) {
   const stateString = todos.map((t) => `${t.id}:${t.status}:${t.content}`).sort().join("|");
-  return crypto2.createHash("sha256").update(stateString).digest("hex").substring(0, 16);
+  return crypto4.createHash("sha256").update(stateString).digest("hex").substring(0, 16);
 }
 
 // src/core/orchestration/memory-instruction-provider.ts