@defai.digital/automatosx 11.3.4 → 11.4.0

package/dist/mcp/index.js

@@ -3,7 +3,7 @@ import * as path4 from 'path';
 import path4__default, { dirname, join, extname as extname$1, basename, resolve, relative, isAbsolute, sep, parse, delimiter } from 'path';
 import { fileURLToPath } from 'url';
 import { mkdir, appendFile, readFile, readdir, writeFile, rename, unlink, copyFile, access, stat, realpath } from 'fs/promises';
-import * as fs3 from 'fs';
+import * as fs4 from 'fs';
 import { existsSync, readFileSync, promises, mkdirSync, createWriteStream, writeFileSync, unlinkSync, constants } from 'fs';
 import Database2 from 'better-sqlite3';
 import { glob } from 'glob';
@@ -20,8 +20,9 @@ import { load } from 'js-yaml';
 import { EventEmitter } from 'events';
 import { findUp } from 'find-up';
 import * as sqliteVec from 'sqlite-vec';
-import { randomUUID } from 'crypto';
+import { randomUUID, randomBytes, createHash } from 'crypto';
 import yaml from 'yaml';
+import { gzipSync, gunzipSync } from 'zlib';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -318,16 +319,16 @@ var init_errors = __esm({
       constructor(message, code = "E1001" /* CONFIG_INVALID */, suggestions = [], context) {
         super(message, code, suggestions, context);
       }
-      static notFound(path6) {
+      static notFound(path7) {
         return new _ConfigError(
-          `Configuration file not found: ${path6}`,
+          `Configuration file not found: ${path7}`,
           "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: path6 }
+          { path: path7 }
         );
       }
       static invalid(reason, context) {
@@ -342,7 +343,7 @@ var init_errors = __esm({
           context
         );
       }
-      static parseError(error, path6) {
+      static parseError(error, path7) {
         return new _ConfigError(
           `Failed to parse configuration: ${error.message}`,
           "E1002" /* CONFIG_PARSE_ERROR */,
@@ -351,7 +352,7 @@ var init_errors = __esm({
             "Use a JSON validator to find syntax errors",
             'Reset to default with "automatosx setup --force"'
           ],
-          { path: path6, originalError: error.message }
+          { path: path7, originalError: error.message }
         );
       }
     };
@@ -1164,11 +1165,11 @@ var init_workspace_indexer = __esm({
       /**
        * Detect file type and language
        */
-      detectTypeAndLanguage(path6, ext) {
-        if (path6.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
+      detectTypeAndLanguage(path7, ext) {
+        if (path7.match(/package\.json|tsconfig\.json|\.config\.(js|ts|json|yaml|yml)|\.eslintrc|\.prettierrc/)) {
           return { type: "config", language: "json" };
         }
-        if (path6.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path6.includes("__tests__")) {
+        if (path7.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/) || path7.includes("__tests__")) {
           const lang = LANGUAGE_MAP[ext];
           return { type: "test", language: lang };
         }
@@ -1185,15 +1186,15 @@ var init_workspace_indexer = __esm({
        *
        * Higher score = more likely to be relevant
        */
-      calculateImportance(path6, type, size) {
+      calculateImportance(path7, type, size) {
         let score = 0.5;
-        if (path6.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
-        if (path6.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
-        if (path6.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
+        if (path7.match(/^(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 1;
+        if (path7.match(/^src\/(index|main|app)\.(ts|js|tsx|jsx)$/)) score = 0.95;
+        if (path7.match(/^src\/cli\/(index|main)\.(ts|js)$/)) score = 0.9;
         if (type === "config") score = 0.85;
-        if (path6.includes("/core/")) score += 0.15;
-        if (path6.includes("/types/")) score += 0.1;
-        if (path6.includes("/utils/")) score += 0.05;
+        if (path7.includes("/core/")) score += 0.15;
+        if (path7.includes("/types/")) score += 0.1;
+        if (path7.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;
@@ -1669,10 +1670,10 @@ function findOnPathUnix(cmdBase) {
   try {
     const which = spawnSync("which", [cmdBase], { timeout: 3e3 });
     if (which.status === 0) {
-      const path6 = which.stdout.toString().trim();
-      if (path6) {
-        logger.debug("Found via which", { cmdBase, path: path6 });
-        return { found: true, path: path6 };
+      const path7 = which.stdout.toString().trim();
+      if (path7) {
+        logger.debug("Found via which", { cmdBase, path: path7 });
+        return { found: true, path: path7 };
       }
     }
   } catch (error) {
@@ -2800,7 +2801,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}
 
@@ -4711,11 +4712,11 @@ var VALIDATION_LIMITS = {
   MAX_PORT: 65535
   // Maximum port number
 };
-function isValidRelativePath(path6) {
-  if (!path6 || typeof path6 !== "string") {
+function isValidRelativePath(path7) {
+  if (!path7 || typeof path7 !== "string") {
     return false;
   }
-  const normalizedPath = path6.replace(/\\/g, "/");
+  const normalizedPath = path7.replace(/\\/g, "/");
   if (normalizedPath.startsWith("/")) {
     return false;
   }
@@ -5432,7 +5433,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(
-  (path6) => !path6.includes("..") && !path6.startsWith("/"),
+  (path7) => !path7.includes("..") && !path7.startsWith("/"),
   "Path must be relative (no ../, no absolute paths)"
 ).describe("Relative path within project");
 var fileExtensionSchema = z.string().regex(
@@ -5772,16 +5773,16 @@ async function loadConfigUncached(projectDir) {
   });
   return config;
 }
-async function loadConfigFile(path6) {
+async function loadConfigFile(path7) {
   try {
-    const content = await readFile(path6, "utf-8");
+    const content = await readFile(path7, "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)`),
-        path6
+        path7
       );
     }
-    const ext = extname(path6).toLowerCase();
+    const ext = extname(path7).toLowerCase();
     let userConfig;
     try {
       if (ext === ".yaml" || ext === ".yml") {
@@ -5790,7 +5791,7 @@ async function loadConfigFile(path6) {
         userConfig = JSON.parse(content);
       }
     } catch (parseError) {
-      throw ConfigError.parseError(parseError, path6);
+      throw ConfigError.parseError(parseError, path7);
     }
     const config = mergeConfig(DEFAULT_CONFIG, userConfig);
     if (config.execution && userConfig.execution?.maxConcurrentAgents === void 0) {
@@ -5806,35 +5807,35 @@ async function loadConfigFile(path6) {
     if (validationErrors.length > 0) {
       throw ConfigError.invalid(
         validationErrors.join("; "),
-        { path: path6, errors: validationErrors }
+        { path: path7, errors: validationErrors }
       );
     }
-    logger.info("Config loaded successfully", { path: normalizePath(path6), format: ext });
+    logger.info("Config loaded successfully", { path: normalizePath(path7), format: ext });
     return config;
   } catch (error) {
     if (error instanceof ConfigError) {
       throw error;
     }
     if (error.code === "ENOENT") {
-      throw ConfigError.notFound(path6);
+      throw ConfigError.notFound(path7);
     }
     if (error.code === "EACCES") {
       throw new ConfigError(
-        `Permission denied reading config: ${path6}`,
+        `Permission denied reading config: ${path7}`,
         "E1002" /* CONFIG_PARSE_ERROR */,
         [
           "Check file permissions",
           "Run with appropriate user privileges",
           "Verify the file is accessible"
         ],
-        { path: path6, error: error.message }
+        { path: path7, error: error.message }
       );
     }
     throw new ConfigError(
       `Failed to load config: ${error.message}`,
       "E1002" /* CONFIG_PARSE_ERROR */,
       ["Check file format and permissions"],
-      { path: path6, originalError: error.message }
+      { path: path7, originalError: error.message }
     );
   }
 }
@@ -5850,8 +5851,8 @@ function validateConfigWithZod(config) {
     return ["Configuration validation failed with unknown error structure"];
   }
   return result.error.issues.map((err) => {
-    const path6 = err.path.join(".");
-    return `${path6}: ${err.message}`;
+    const path7 = err.path.join(".");
+    return `${path7}: ${err.message}`;
   });
 }
 function validateConfig(config) {
@@ -6261,8 +6262,8 @@ var PathError = class extends Error {
 };
 
 // src/shared/validation/path-resolver.ts
-function isWindowsPath(path6) {
-  return /^[a-zA-Z]:[/\\]/.test(path6);
+function isWindowsPath(path7) {
+  return /^[a-zA-Z]:[/\\]/.test(path7);
 }
 async function detectProjectRoot(startDir = process.cwd()) {
   if (process.env.AUTOMATOSX_PROJECT_ROOT) {
@@ -6362,8 +6363,8 @@ var PathResolver = class {
   /**
    * Validate path is within allowed base directory
    */
-  validatePath(path6, baseDir) {
-    const normalized = normalizePath(resolvePath(path6));
+  validatePath(path7, baseDir) {
+    const normalized = normalizePath(resolvePath(path7));
     const base = normalizePath(resolvePath(baseDir));
     const separator = "/";
     const pathWithSep = normalized + separator;
@@ -6373,15 +6374,15 @@ var PathResolver = class {
   /**
    * Check if path is within allowed boundaries
    */
-  isPathAllowed(path6) {
-    const boundary = this.checkBoundaries(path6);
+  isPathAllowed(path7) {
+    const boundary = this.checkBoundaries(path7);
     return boundary === "agent_workspace" || boundary === "user_project";
   }
   /**
    * Check which boundary a path belongs to
    */
-  checkBoundaries(path6) {
-    const normalized = resolvePath(path6);
+  checkBoundaries(path7) {
+    const normalized = resolvePath(path7);
     if (this.validatePath(normalized, this.config.agentWorkspace)) {
       return "agent_workspace";
     }
@@ -6399,15 +6400,15 @@ var PathResolver = class {
   /**
    * Get relative path from project root
    */
-  getRelativeToProject(path6) {
-    const normalized = resolvePath(path6);
+  getRelativeToProject(path7) {
+    const normalized = resolvePath(path7);
     return normalizePath(getRelativePath(this.config.projectDir, normalized));
   }
   /**
    * Get relative path from working directory
    */
-  getRelativeToWorking(path6) {
-    const normalized = resolvePath(path6);
+  getRelativeToWorking(path7) {
+    const normalized = resolvePath(path7);
     return normalizePath(getRelativePath(this.config.workingDir, normalized));
   }
   /**
@@ -6426,11 +6427,11 @@ var PathResolver = class {
    * Validate path is within project boundaries
    * @throws PathError if outside project
    */
-  validateInProject(path6) {
-    const boundary = this.checkBoundaries(path6);
+  validateInProject(path7) {
+    const boundary = this.checkBoundaries(path7);
     if (boundary === "outside_boundaries" || boundary === "system_restricted") {
       throw new PathError("Path outside project directory", {
-        path: path6,
+        path: path7,
         projectDir: this.config.projectDir,
         boundary
       });
@@ -8297,18 +8298,18 @@ var ProviderSessionManager = class {
 };
 var providerSessionInstances = /* @__PURE__ */ new Map();
 async function getProviderSession(workspacePath) {
-  let path6;
+  let path7;
   {
     if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-      path6 = process.cwd();
+      path7 = process.cwd();
     } else {
-      path6 = await detectProjectRoot();
+      path7 = await detectProjectRoot();
     }
   }
-  if (!providerSessionInstances.has(path6)) {
-    providerSessionInstances.set(path6, new ProviderSessionManager(path6));
+  if (!providerSessionInstances.has(path7)) {
+    providerSessionInstances.set(path7, new ProviderSessionManager(path7));
   }
-  return providerSessionInstances.get(path6);
+  return providerSessionInstances.get(path7);
 }
 
 // src/core/router/router.ts
@@ -15242,9 +15243,9 @@ var DependencyGraphBuilder = class {
   detectCycles(graph) {
     const visiting = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
-    const visit = (nodeName, path6) => {
+    const visit = (nodeName, path7) => {
       if (visiting.has(nodeName)) {
-        throw new Error(`Circular dependency detected: ${[...path6, nodeName].join(" \u2192 ")}`);
+        throw new Error(`Circular dependency detected: ${[...path7, nodeName].join(" \u2192 ")}`);
       }
       if (visited.has(nodeName)) {
         return;
@@ -15259,7 +15260,7 @@ var DependencyGraphBuilder = class {
       }
       visiting.add(nodeName);
       for (const dependency of node.dependencies) {
-        visit(dependency, [...path6, nodeName]);
+        visit(dependency, [...path7, nodeName]);
       }
       visiting.delete(nodeName);
       visited.add(nodeName);
@@ -16992,59 +16993,59 @@ var DANGEROUS_PATH_PATTERNS = [
   // Common data drive (Windows, alt format)
 ];
 var SUSPICIOUS_PATH_CHARS = /[<>:|"]/;
-function validatePathParameter(path6, paramName, projectRoot = process.cwd()) {
-  if (!path6 || path6.trim() === "") {
+function validatePathParameter(path7, paramName, projectRoot = process.cwd()) {
+  if (!path7 || path7.trim() === "") {
     throw new ValidationError(
       `Invalid ${paramName}: path cannot be empty`,
       -32602 /* InvalidParams */,
-      { path: path6, paramName }
+      { path: path7, paramName }
     );
   }
   for (const pattern of DANGEROUS_PATH_PATTERNS) {
-    if (path6.includes(pattern)) {
+    if (path7.includes(pattern)) {
       throw new ValidationError(
         `Invalid ${paramName}: path contains dangerous pattern "${pattern}"`,
         -32602 /* InvalidParams */,
-        { path: path6, paramName, pattern }
+        { path: path7, paramName, pattern }
       );
     }
   }
-  if (isAbsolute(path6)) {
+  if (isAbsolute(path7)) {
     throw new ValidationError(
       `Invalid ${paramName}: absolute paths are not allowed`,
       -32602 /* InvalidParams */,
-      { path: path6, paramName }
+      { path: path7, paramName }
     );
   }
   try {
-    const resolvedPath = resolve(projectRoot, path6);
+    const resolvedPath = resolve(projectRoot, path7);
     const normalizedRoot = resolve(projectRoot);
     if (!resolvedPath.startsWith(normalizedRoot + sep) && resolvedPath !== normalizedRoot) {
       throw new ValidationError(
         `Invalid ${paramName}: path escapes project boundary`,
         -32602 /* InvalidParams */,
-        { path: path6, paramName, projectRoot, resolvedPath }
+        { path: path7, paramName, projectRoot, resolvedPath }
       );
     }
   } catch (error) {
     throw new ValidationError(
       `Invalid ${paramName}: path resolution failed`,
       -32602 /* InvalidParams */,
-      { path: path6, paramName, error: String(error) }
+      { path: path7, paramName, error: String(error) }
     );
   }
-  if (path6.includes("\0")) {
+  if (path7.includes("\0")) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains null byte`,
       -32602 /* InvalidParams */,
-      { path: path6, paramName }
+      { path: path7, paramName }
     );
   }
-  if (SUSPICIOUS_PATH_CHARS.test(path6)) {
+  if (SUSPICIOUS_PATH_CHARS.test(path7)) {
     throw new ValidationError(
       `Invalid ${paramName}: path contains invalid characters`,
       -32602 /* InvalidParams */,
-      { path: path6, paramName }
+      { path: path7, paramName }
     );
   }
 }
@@ -17740,8 +17741,8 @@ function createMemoryExportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_export called", { input });
     try {
-      const { path: path6 } = input;
-      const absolutePath = resolveExportPath(deps.pathResolver, path6);
+      const { path: path7 } = input;
+      const absolutePath = resolveExportPath(deps.pathResolver, path7);
       const exported = await deps.memoryManager.exportToJSON(absolutePath);
       const result = {
         success: true,
@@ -17777,8 +17778,8 @@ function createMemoryImportHandler(deps) {
   return async (input) => {
     logger.info("[MCP] memory_import called", { input });
     try {
-      const { path: path6 } = input;
-      const absolutePath = resolveImportPath(deps.pathResolver, path6);
+      const { path: path7 } = input;
+      const absolutePath = resolveImportPath(deps.pathResolver, path7);
       const imported = await deps.memoryManager.importFromJSON(absolutePath);
       const result = {
         success: true,
@@ -18133,6 +18134,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((resolve5, reject) => {
+      if (signal?.aborted) {
+        reject(new Error("Aborted"));
+        return;
+      }
+      const abortHandler = () => {
+        clearTimeout(timeoutId);
+        reject(new Error("Aborted"));
+      };
+      const timeoutId = setTimeout(() => {
+        signal?.removeEventListener("abort", abortHandler);
+        resolve5();
+      }, 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();
@@ -18552,7 +20477,7 @@ var ConnectionTimeoutError = class extends McpClientError {
 };
 
 // src/providers/mcp/pool-manager.ts
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG6 = {
   maxConnectionsPerProvider: 2,
   idleTimeoutMs: 3e5,
   // 5 minutes
@@ -18573,7 +20498,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();
@@ -20495,7 +22420,13 @@ var McpServer = class _McpServer {
           },
           required: ["agent", "task"]
         }
-      }
+      },
+      // v11.3.5: Task Engine tools
+      createTaskSchema,
+      runTaskSchema,
+      getTaskResultSchema,
+      listTasksSchema,
+      deleteTaskSchema
     ];
   }
   /**
@@ -20670,6 +22601,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())