@poetic-ai/poetic 1.42.0

package/dist/chunk-JQNJB2BB.js

@@ -0,0 +1,2440 @@
+import {
+  stripPromptInjections
+} from "./chunk-FQ7FSZRW.js";
+import {
+  DomainAnalyzer
+} from "./chunk-XEP5NQ5Y.js";
+import {
+  TokenEstimator,
+  UTILIZATION_SPLIT_PERCENT,
+  UTILIZATION_WARN_PERCENT
+} from "./chunk-ZSKKMTQJ.js";
+import {
+  estimateTokensHeuristic
+} from "./chunk-LFTQVYBB.js";
+import {
+  resolveDefaultProvider,
+  resolveSplitterModel
+} from "./chunk-XPU2XADL.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  PROJECT_LANGUAGES
+} from "./chunk-FHOWVDF5.js";
+import {
+  languageForProjectPath
+} from "./chunk-UDMS5AD3.js";
+import {
+  debugLog,
+  emitCustomWarning,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_SPLITTER_DEDUP_THRESHOLD,
+  POETIC_SPLITTER_SHADOW,
+  POETIC_SPLITTER_SHADOW_TIMEOUT_MS,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/orchestrator/task-splitter.ts
+import { createHash } from "crypto";
+
+// src/core/routing/task-characteristics-analyzer.ts
+var ROUTABLE_PROJECT_LANGUAGES = PROJECT_LANGUAGES.filter(
+  (language) => language !== "docs" && language !== "unknown"
+);
+var PROJECT_LANGUAGE_MATCHERS = {
+  node: [/\bnode(?:\.?js)?\b/i],
+  typescript: [/\btypescript\b/i, /\bts\b/i],
+  javascript: [/\bjavascript\b/i, /\bjs\b/i],
+  c: [/\bc language\b/i, /\blanguage c\b/i],
+  cpp: [/\bc\+\+(?:\d{2})?(?![\w+])/i, /\bcpp\b/i],
+  python: [/\bpython\b/i, /\bpy\b/i],
+  go: [
+    /\bgolang\b/i,
+    /\bgo language\b/i,
+    /\bgo (?:code|module|package|program(?:ming)?|service|binary|concurrency|goroutine|toolchain)\b/i,
+    /\b(?:written|write|rewritten|rewrite|ported|port|implement(?:ed|ing)?|using)\s+(?:in\s+)?go\b/i,
+    /\bin go\b/i
+  ],
+  rust: [/\brust\b/i],
+  java: [/\bjava\b/i],
+  // Explicit prose aliases only — never match arbitrary domains like example.net.
+  // Standalone/whitespace-delimited `.NET` requires a non-domain left boundary.
+  dotnet: [
+    /\bc#(?!\w)/i,
+    /\bcsharp\b/i,
+    /\bdotnet\b/i,
+    /\basp\.net\b/i,
+    /(?:^|[\s,;:()[\]{}"'`/])\.NET\b/i
+  ],
+  swift: [/\bswift\b/i],
+  kotlin: [/\bkotlin\b/i],
+  dart: [/\bdart\b/i],
+  ruby: [/\bruby\b/i, /\brb\b/i],
+  php: [/\bphp\b/i],
+  shell: [/\bshell script(?:ing)?\b/i, /\b(?:bash|zsh|fish|ksh)\b/i],
+  powershell: [/\bpowershell\b/i],
+  r: [/\br language\b/i, /\b(?:written|write|implemented|implement|using)\s+(?:in\s+)?r\b/i],
+  sql: [/\bsql\b/i]
+};
+var TaskCharacteristicsAnalyzer = class {
+  analyze(taskDescription, domainAnalysis) {
+    const characteristics = this.extractCharacteristics(taskDescription, domainAnalysis);
+    const confidence = this.calculateConfidence(characteristics);
+    const rationale = this.generateRationale(characteristics, domainAnalysis);
+    const recommendedApproach = this.recommendApproach(characteristics, domainAnalysis);
+    const estimatedComplexity = this.estimateComplexity(characteristics, domainAnalysis);
+    const timeEstimate = this.estimateTime(characteristics, domainAnalysis);
+    return {
+      characteristics,
+      confidence,
+      rationale,
+      recommendedApproach,
+      estimatedComplexity,
+      timeEstimate
+    };
+  }
+  extractCharacteristics(taskDescription, domainAnalysis) {
+    const lowerTask = taskDescription.toLowerCase();
+    return {
+      // File and language analysis
+      fileTypes: this.extractFileTypes(taskDescription),
+      programmingLanguages: this.extractProgrammingLanguages(taskDescription),
+      fileCount: domainAnalysis.filesMentioned.length,
+      // Complexity indicators
+      hasMultipleFiles: domainAnalysis.filesMentioned.length > 1,
+      hasComplexDependencies: this.hasComplexDependencies(lowerTask),
+      requiresRefactoring: this.requiresRefactoring(lowerTask),
+      requiresTesting: this.requiresTesting(lowerTask),
+      // Task intent analysis
+      isBugFix: this.isBugFix(lowerTask),
+      isFeatureAddition: this.isFeatureAddition(lowerTask),
+      isRefactoring: this.isRefactoring(lowerTask),
+      isDocumentation: this.isDocumentation(lowerTask),
+      isTesting: this.isTesting(lowerTask),
+      // Technical requirements
+      requiresDatabaseChanges: this.requiresDatabaseChanges(lowerTask),
+      requiresAPIIntegration: this.requiresAPIIntegration(lowerTask),
+      requiresUIImplementation: this.requiresUIImplementation(lowerTask),
+      requiresConfiguration: this.requiresConfiguration(lowerTask),
+      // Performance and quality indicators
+      requiresOptimization: this.requiresOptimization(lowerTask),
+      requiresSecurityReview: this.requiresSecurityReview(lowerTask),
+      requiresCodeReview: this.requiresCodeReview(lowerTask),
+      // Context and scope
+      isCriticalPath: this.isCriticalPath(lowerTask),
+      affectsMultipleModules: this.affectsMultipleModules(lowerTask, domainAnalysis),
+      requiresCoordination: this.requiresCoordination(lowerTask, domainAnalysis)
+    };
+  }
+  extractFileTypes(taskDescription) {
+    const filePattern = /\.([a-zA-Z0-9]+)\b/g;
+    const types = [];
+    for (const match of taskDescription.matchAll(filePattern)) {
+      const ext = match[1];
+      if (ext) types.push(ext);
+    }
+    return [...new Set(types)];
+  }
+  extractProgrammingLanguages(taskDescription) {
+    const detected = /* @__PURE__ */ new Set();
+    for (const language of ROUTABLE_PROJECT_LANGUAGES) {
+      const patterns = PROJECT_LANGUAGE_MATCHERS[language];
+      if (patterns.some((pattern) => pattern.test(taskDescription))) {
+        detected.add(language);
+      }
+    }
+    for (const ext of this.extractFileTypes(taskDescription)) {
+      const language = languageForProjectPath(`file.${ext}`);
+      if (language && language !== "docs" && language !== "unknown" && ROUTABLE_PROJECT_LANGUAGES.includes(language)) {
+        detected.add(language);
+      }
+    }
+    return ROUTABLE_PROJECT_LANGUAGES.filter((language) => detected.has(language));
+  }
+  hasComplexDependencies(taskDescription) {
+    const complexDependencyKeywords = [
+      "dependency",
+      "dependencies",
+      "import",
+      "require",
+      "module",
+      "package",
+      "library",
+      "framework",
+      "api",
+      "integration",
+      "external",
+      "third-party",
+      "npm",
+      "yarn",
+      "pip",
+      "maven"
+    ];
+    return complexDependencyKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresRefactoring(taskDescription) {
+    const refactoringKeywords = [
+      "refactor",
+      "refactoring",
+      "restructure",
+      "reorganize",
+      "clean up",
+      "cleanup",
+      "optimize",
+      "improve",
+      "modernize",
+      "update",
+      "upgrade",
+      "migrate",
+      "convert"
+    ];
+    return refactoringKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresTesting(taskDescription) {
+    const testingKeywords = [
+      "test",
+      "testing",
+      "spec",
+      "specification",
+      "unit test",
+      "integration test",
+      "e2e",
+      "end-to-end",
+      "coverage",
+      "assert",
+      "expect",
+      "mock",
+      "stub",
+      "fixture"
+    ];
+    return testingKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  isBugFix(taskDescription) {
+    const bugFixKeywords = [
+      "bug",
+      "fix",
+      "error",
+      "issue",
+      "problem",
+      "bugfix",
+      "resolve",
+      "correct",
+      "repair",
+      "patch",
+      "hotfix"
+    ];
+    return bugFixKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  isFeatureAddition(taskDescription) {
+    const featureKeywords = [
+      "add",
+      "create",
+      "implement",
+      "build",
+      "develop",
+      "feature",
+      "functionality",
+      "capability",
+      "new",
+      "enhancement",
+      "improvement",
+      "extension"
+    ];
+    return featureKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  isRefactoring(taskDescription) {
+    const refactoringKeywords = [
+      "refactor",
+      "refactoring",
+      "restructure",
+      "reorganize",
+      "rewrite",
+      "redesign",
+      "rearchitect"
+    ];
+    return refactoringKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  isDocumentation(taskDescription) {
+    const documentationKeywords = [
+      "documentation",
+      "docs",
+      "readme",
+      "comment",
+      "explain",
+      "describe",
+      "document",
+      "guide",
+      "tutorial",
+      "api docs"
+    ];
+    return documentationKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  isTesting(taskDescription) {
+    const testingKeywords = [
+      "test",
+      "testing",
+      "spec",
+      "specification",
+      "unit test",
+      "integration test",
+      "e2e",
+      "end-to-end",
+      "coverage"
+    ];
+    return testingKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresDatabaseChanges(taskDescription) {
+    const databaseKeywords = [
+      "database",
+      "db",
+      "sql",
+      "query",
+      "table",
+      "schema",
+      "migration",
+      "migrate",
+      "data",
+      "record",
+      "entity",
+      "orm",
+      "sequelize",
+      "prisma",
+      "typeorm"
+    ];
+    return databaseKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresAPIIntegration(taskDescription) {
+    const apiKeywords = [
+      "api",
+      "endpoint",
+      "rest",
+      "graphql",
+      "http",
+      "request",
+      "response",
+      "fetch",
+      "axios",
+      "fetch",
+      "integration",
+      "service",
+      "microservice",
+      "webhook",
+      "callback"
+    ];
+    return apiKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresUIImplementation(taskDescription) {
+    const uiKeywords = [
+      "ui",
+      "user interface",
+      "frontend",
+      "component",
+      "react",
+      "vue",
+      "angular",
+      "html",
+      "css",
+      "styling",
+      "design",
+      "layout",
+      "responsive",
+      "mobile",
+      "desktop",
+      "button",
+      "form",
+      "input",
+      "modal",
+      "dialog",
+      "page"
+    ];
+    return uiKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresConfiguration(taskDescription) {
+    const configKeywords = [
+      "config",
+      "configuration",
+      "settings",
+      "environment",
+      "env",
+      "variables",
+      "properties",
+      "yaml",
+      "json",
+      "ini",
+      "toml",
+      "setup",
+      "install",
+      "deploy"
+    ];
+    return configKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresOptimization(taskDescription) {
+    const optimizationKeywords = [
+      "optimize",
+      "optimization",
+      "performance",
+      "speed",
+      "fast",
+      "efficient",
+      "memory",
+      "cpu",
+      "bottleneck",
+      "profiling",
+      "benchmark",
+      "improve",
+      "enhance"
+    ];
+    return optimizationKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresSecurityReview(taskDescription) {
+    const securityKeywords = [
+      "security",
+      "secure",
+      "vulnerability",
+      "auth",
+      "authentication",
+      "authorization",
+      "permission",
+      "access",
+      "encrypt",
+      "hash",
+      "password",
+      "token",
+      "jwt",
+      "oauth",
+      "ssl",
+      "tls"
+    ];
+    return securityKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  requiresCodeReview(taskDescription) {
+    const reviewKeywords = [
+      "review",
+      "code review",
+      "pr",
+      "pull request",
+      "merge",
+      "approve",
+      "feedback",
+      "comment",
+      "suggestion"
+    ];
+    return reviewKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  isCriticalPath(taskDescription) {
+    const criticalKeywords = [
+      "critical",
+      "urgent",
+      "priority",
+      "important",
+      "blocking",
+      "hotfix",
+      "emergency",
+      "asap",
+      "immediately",
+      "deadline"
+    ];
+    return criticalKeywords.some((keyword) => taskDescription.includes(keyword));
+  }
+  affectsMultipleModules(taskDescription, domainAnalysis) {
+    return domainAnalysis.filesMentioned.length > 3 || domainAnalysis.featureCount > 2 || taskDescription.toLowerCase().includes("multiple") || taskDescription.toLowerCase().includes("several");
+  }
+  requiresCoordination(taskDescription, domainAnalysis) {
+    return domainAnalysis.filesMentioned.length > 5 || taskDescription.toLowerCase().includes("team") || taskDescription.toLowerCase().includes("collaborate") || taskDescription.toLowerCase().includes("coordinate") || taskDescription.toLowerCase().includes("sync");
+  }
+  calculateConfidence(characteristics) {
+    let confidence = 0.5;
+    if (characteristics.fileCount > 0) confidence += 0.1;
+    if (characteristics.programmingLanguages.length > 0) confidence += 0.1;
+    if (characteristics.isBugFix || characteristics.isFeatureAddition) confidence += 0.1;
+    if (characteristics.requiresTesting) confidence += 0.1;
+    if (characteristics.requiresRefactoring) confidence += 0.1;
+    if (characteristics.fileCount === 0 && characteristics.programmingLanguages.length === 0) {
+      confidence -= 0.2;
+    }
+    return Math.min(1, Math.max(0, confidence));
+  }
+  generateRationale(characteristics, _domainAnalysis) {
+    const rationale = [];
+    rationale.push(`File types detected: ${characteristics.fileTypes.join(", ") || "none"}`);
+    rationale.push(
+      `Programming languages: ${characteristics.programmingLanguages.join(", ") || "none"}`
+    );
+    rationale.push(`File count: ${characteristics.fileCount}`);
+    if (characteristics.isBugFix) rationale.push("Task type: Bug fix");
+    if (characteristics.isFeatureAddition) rationale.push("Task type: Feature addition");
+    if (characteristics.isRefactoring) rationale.push("Task type: Refactoring");
+    if (characteristics.isDocumentation) rationale.push("Task type: Documentation");
+    if (characteristics.isTesting) rationale.push("Task type: Testing");
+    if (characteristics.requiresDatabaseChanges) rationale.push("Requires database changes");
+    if (characteristics.requiresAPIIntegration) rationale.push("Requires API integration");
+    if (characteristics.requiresUIImplementation) rationale.push("Requires UI implementation");
+    if (characteristics.requiresConfiguration) rationale.push("Requires configuration changes");
+    if (characteristics.isCriticalPath) rationale.push("Critical path task");
+    if (characteristics.affectsMultipleModules) rationale.push("Affects multiple modules");
+    if (characteristics.requiresCoordination) rationale.push("Requires coordination");
+    return rationale;
+  }
+  recommendApproach(characteristics, _domainAnalysis) {
+    if (characteristics.isCriticalPath || characteristics.isBugFix || characteristics.requiresSecurityReview) {
+      return "conservative";
+    }
+    if (characteristics.isFeatureAddition && !characteristics.isCriticalPath) {
+      return "innovative";
+    }
+    if (characteristics.isRefactoring && characteristics.affectsMultipleModules) {
+      return "hybrid";
+    }
+    return "hybrid";
+  }
+  estimateComplexity(characteristics, _domainAnalysis) {
+    let complexityScore = 0;
+    if (characteristics.fileCount > 10) complexityScore += 3;
+    else if (characteristics.fileCount > 5) complexityScore += 2;
+    else if (characteristics.fileCount > 1) complexityScore += 1;
+    if (characteristics.requiresDatabaseChanges) complexityScore += 2;
+    if (characteristics.requiresAPIIntegration) complexityScore += 2;
+    if (characteristics.requiresUIImplementation) complexityScore += 2;
+    if (characteristics.requiresConfiguration) complexityScore += 1;
+    if (characteristics.isRefactoring) complexityScore += 2;
+    if (characteristics.affectsMultipleModules) complexityScore += 2;
+    if (characteristics.requiresCoordination) complexityScore += 1;
+    if (_domainAnalysis.complexity === "high") complexityScore += 3;
+    else if (_domainAnalysis.complexity === "medium") complexityScore += 2;
+    else complexityScore += 1;
+    if (complexityScore >= 8) return "high";
+    if (complexityScore >= 4) return "medium";
+    return "low";
+  }
+  /**
+   * Estimate an advisory AI expected wall-clock runtime range (minutes) from a
+   * task's characteristics. AI-native bands per the estimation doctrine (minutes
+   * for simple work, up to a few hours for larger implementation) — NOT human
+   * effort. Advisory guidance only; never a gate ([B5]).
+   */
+  estimateTime(characteristics, domainAnalysis) {
+    const baseMinutes = 30;
+    let multiplier = 1;
+    let confidence = 0.7;
+    if (characteristics.fileCount > 10) multiplier += 2;
+    else if (characteristics.fileCount > 5) multiplier += 1.5;
+    else if (characteristics.fileCount > 1) multiplier += 0.5;
+    if (characteristics.requiresDatabaseChanges) multiplier += 1;
+    if (characteristics.requiresAPIIntegration) multiplier += 1;
+    if (characteristics.requiresUIImplementation) multiplier += 1;
+    if (characteristics.requiresConfiguration) multiplier += 0.5;
+    if (characteristics.isRefactoring) multiplier += 1.5;
+    if (characteristics.isTesting) multiplier += 0.5;
+    if (characteristics.isDocumentation) multiplier += 0.3;
+    if (domainAnalysis.complexity === "high") multiplier += 2;
+    else if (domainAnalysis.complexity === "medium") multiplier += 1;
+    const min = Math.round(baseMinutes * multiplier * 0.7);
+    const max = Math.round(baseMinutes * multiplier * 1.5);
+    if (characteristics.fileCount === 0) confidence -= 0.2;
+    if (characteristics.programmingLanguages.length === 0) confidence -= 0.1;
+    if (characteristics.affectsMultipleModules) confidence -= 0.1;
+    return {
+      min: Math.max(5, min),
+      // Floor: a few minutes for the smallest AI change
+      max: Math.min(480, max),
+      // Ceiling: cap advisory AI runtime at a few hours
+      confidence: Math.max(0.3, Math.min(1, confidence))
+    };
+  }
+};
+
+// src/orchestrator/task-splitter.ts
+var SUBTASK_DEDUP_THRESHOLD = readEnv(POETIC_SPLITTER_DEDUP_THRESHOLD).value ?? 0.7;
+var SPLITTER_SHADOW_TIMEOUT_MS = readEnv(POETIC_SPLITTER_SHADOW_TIMEOUT_MS).value ?? 45e3;
+var FILE_PATH_TOKEN_REGEX = /(?:[a-zA-Z]:)?(?:\.?\.?\/)?(?:[a-zA-Z0-9_\-./\\]+?\.(?:ts|js|tsx|jsx|py|java|go|rs|cpp|c|h|mjs|cjs|json|md|yaml|yml))\b/g;
+function isAnalysisSubTask(subTask) {
+  return subTask.executionIntent === "analysis" || subTask.editsAllowed === false;
+}
+var TaskSplitter = class _TaskSplitter {
+  // Strategies that are allowed to produce zero subtasks
+  static ALLOW_ZERO_SUBTASKS = /* @__PURE__ */ new Set([
+    "no-split"
+    // Future strategies that allow zero subtasks can be added here
+  ]);
+  domainAnalyzer;
+  taskCharacteristicsAnalyzer;
+  tokenEstimator;
+  splitterShadowRunner;
+  constructor(deps) {
+    this.domainAnalyzer = deps?.domainAnalyzer ?? new DomainAnalyzer();
+    this.taskCharacteristicsAnalyzer = deps?.taskCharacteristicsAnalyzer ?? new TaskCharacteristicsAnalyzer();
+    this.tokenEstimator = deps?.tokenEstimator ?? new TokenEstimator();
+    this.splitterShadowRunner = deps?.splitterShadowRunner ?? this.defaultSplitterShadowRunner;
+  }
+  /**
+   * Split a task into N parallel sub-tasks with routing decisions
+   *
+   * @param prompt - Original task description
+   * @param numAgents - Number of parallel agents to use
+   * @param routingOptions - Optional routing configuration
+   * @param splitOptions - Optional splitting configuration (e.g., sequential batching, token-aware)
+   * @returns Split task result with sub-tasks and routing decisions
+   */
+  async split(prompt, numAgents, routingOptions = {}, splitOptions) {
+    if (numAgents < 1) {
+      throw new Error("Number of agents must be at least 1");
+    }
+    const strippedPrompt = stripPromptInjections(prompt);
+    const heuristicPrompt = strippedPrompt.length > 0 ? strippedPrompt : prompt;
+    debugLog("[TaskSplitter] Splitting prompt:", prompt);
+    debugLog("[TaskSplitter] Requested agents:", numAgents);
+    let tokenAnalysis;
+    if (splitOptions?.contextMode === "auto") {
+      if (!splitOptions?.targetProvider || !splitOptions?.targetModel) {
+        emitWarning(
+          "CFG-002",
+          {
+            taskId: "unknown",
+            subsystem: "orchestrator",
+            executionPhase: "setup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              operation: "tokenAnalysis",
+              contextMode: "auto",
+              reason: "Missing targetProvider or targetModel"
+            },
+            recovered: true,
+            recoveryMechanism: "Skipping token analysis - using semantic splitting only"
+          }
+        );
+      } else if (splitOptions?.targetProvider && splitOptions?.targetModel) {
+        try {
+          tokenAnalysis = await this.tokenEstimator.analyzeTask(
+            prompt,
+            splitOptions.targetProvider,
+            splitOptions.targetModel
+          );
+          debugLog("[TaskSplitter] Token Analysis:");
+          debugLog(`  Estimated tokens: ${tokenAnalysis.estimatedTokens}`);
+          debugLog(`  Context window: ${tokenAnalysis.contextWindow}`);
+          debugLog(`  Utilization: ${tokenAnalysis.utilizationPercent.toFixed(1)}%`);
+          debugLog(
+            `  Adjusted utilization: ${tokenAnalysis.adjustedUtilizationPercent.toFixed(1)}%`
+          );
+          debugLog(`  Estimation confidence: ${tokenAnalysis.estimationConfidence.toFixed(2)}`);
+          debugLog(`  Should split: ${tokenAnalysis.shouldSplit}`);
+          if (splitOptions.forceSplit) {
+            debugLog(
+              "[TaskSplitter] Force split enabled, will attempt splitting regardless of threshold"
+            );
+          }
+          if (tokenAnalysis.adjustedUtilizationPercent > UTILIZATION_WARN_PERCENT && tokenAnalysis.adjustedUtilizationPercent <= UTILIZATION_SPLIT_PERCENT) {
+            emitWarning(
+              "PERF-001",
+              {
+                taskId: "unknown",
+                subsystem: "orchestrator",
+                executionPhase: "setup"
+              },
+              {
+                severity: "WARN" /* WARN */,
+                metadata: {
+                  operation: "tokenAnalysis",
+                  adjustedUtilizationPercent: tokenAnalysis.adjustedUtilizationPercent,
+                  estimatedTokens: tokenAnalysis.estimatedTokens,
+                  contextWindow: tokenAnalysis.contextWindow
+                }
+              }
+            );
+          }
+          if (tokenAnalysis.adjustedUtilizationPercent > UTILIZATION_SPLIT_PERCENT) {
+            if (tokenAnalysis.estimationConfidence < 0.5) {
+              emitWarning(
+                "CFG-002",
+                {
+                  taskId: "unknown",
+                  subsystem: "orchestrator",
+                  executionPhase: "setup"
+                },
+                {
+                  severity: "WARN" /* WARN */,
+                  metadata: {
+                    operation: "tokenAnalysis",
+                    estimationConfidence: tokenAnalysis.estimationConfidence,
+                    adjustedUtilizationPercent: tokenAnalysis.adjustedUtilizationPercent
+                  },
+                  recovered: true,
+                  recoveryMechanism: "Proceeding without auto-split (use --force-split to override)"
+                }
+              );
+            } else {
+              debugLog(
+                `[TaskSplitter] High confidence (${tokenAnalysis.estimationConfidence.toFixed(2)}), proceeding with split`
+              );
+            }
+          }
+          if (splitOptions.noSplit) {
+            debugLog("[TaskSplitter] No split forced, returning single task");
+            const result2 = {
+              subTasks: [
+                {
+                  id: 1,
+                  description: prompt,
+                  files: [],
+                  context: "",
+                  dependencies: []
+                }
+              ],
+              pendingSubTasks: [],
+              strategy: "no-split",
+              reasoning: "Manual override: --no-split flag",
+              tokenAnalysis
+            };
+            this.validateCompleteExecution(result2);
+            return await this.finalizeSplitResult(result2, prompt, numAgents, splitOptions);
+          }
+          if (!tokenAnalysis.shouldSplit && !splitOptions.forceSplit) {
+            const earlySignals = this.analyzeCouplingSignals(heuristicPrompt);
+            const hasSemanticRoutingNeed = earlySignals.coupled || earlySignals.filePaths.length > 1 || this.hasIndependentMechanicalFileList(heuristicPrompt);
+            if (!hasSemanticRoutingNeed) {
+              debugLog(
+                `[TaskSplitter] Task within threshold (${tokenAnalysis.adjustedUtilizationPercent.toFixed(1)}%), no multi-file/coupling signals \u2014 no splitting needed`
+              );
+              const result2 = {
+                subTasks: [
+                  {
+                    id: 1,
+                    description: prompt,
+                    files: [],
+                    context: "",
+                    dependencies: []
+                  }
+                ],
+                pendingSubTasks: [],
+                strategy: "no-split",
+                reasoning: `Task uses ${tokenAnalysis.adjustedUtilizationPercent.toFixed(1)}% of adjusted context window (under threshold)`,
+                tokenAnalysis
+              };
+              this.validateCompleteExecution(result2);
+              return await this.finalizeSplitResult(result2, prompt, numAgents, splitOptions);
+            }
+            debugLog(
+              "[TaskSplitter] Task within token threshold but multi-file/coupling signals present \u2014 continuing semantic routing"
+            );
+          }
+          if (tokenAnalysis.shouldSplit) {
+            debugLog(
+              `[TaskSplitter] Task exceeds threshold, applying ${tokenAnalysis.strategy} splitting`
+            );
+          }
+          if (tokenAnalysis.shouldSplit && tokenAnalysis.strategy === "sequential") {
+            const sequentialSignals = this.analyzeCouplingSignals(heuristicPrompt);
+            if (!sequentialSignals.coupled && sequentialSignals.filePaths.length <= 1) {
+              debugLog("[TaskSplitter] Using sequential chunking for very large task");
+              const sequentialResult = await this.splitSequentially(
+                prompt,
+                numAgents,
+                tokenAnalysis.estimatedTokens,
+                tokenAnalysis.thresholdTokens,
+                tokenAnalysis
+              );
+              return await this.finalizeSplitResult(
+                sequentialResult,
+                prompt,
+                numAgents,
+                splitOptions
+              );
+            }
+            debugLog(
+              "[TaskSplitter] Sequential token strategy deferred \u2014 multi-file/coupling requires semantic routing"
+            );
+          }
+        } catch (error) {
+          emitWarning(
+            "CFG-002",
+            {
+              taskId: "unknown",
+              subsystem: "orchestrator",
+              executionPhase: "setup"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: "tokenAnalysis",
+                error: error instanceof Error ? error.message : String(error)
+              },
+              recovered: true,
+              recoveryMechanism: "Proceeding without auto-decomposition - using semantic splitting"
+            }
+          );
+        }
+      }
+    } else {
+      debugLog("[TaskSplitter] Token analysis skipped (contextMode=off)");
+      if (splitOptions?.noSplit) {
+        debugLog("[TaskSplitter] No split forced, returning single task");
+        const result2 = {
+          subTasks: [
+            {
+              id: 1,
+              description: prompt,
+              files: [],
+              context: "",
+              dependencies: []
+            }
+          ],
+          pendingSubTasks: [],
+          strategy: "no-split",
+          reasoning: "Manual override: --no-split flag",
+          tokenAnalysis: void 0
+        };
+        this.validateCompleteExecution(result2);
+        return await this.finalizeSplitResult(result2, prompt, numAgents, splitOptions);
+      }
+    }
+    const domainAnalysis = await this.safeAnalyzeDomain(heuristicPrompt);
+    const taskAnalysis = this.safeAnalyzeTaskCharacteristics(heuristicPrompt, domainAnalysis);
+    const attachMetadata = (subTasks, heuristics2, strategy) => this.attachMetadataToSubTasks(
+      subTasks,
+      prompt,
+      heuristics2,
+      domainAnalysis,
+      taskAnalysis,
+      strategy
+    );
+    if (numAgents === 1) {
+      const heuristics2 = /* @__PURE__ */ new Set(["single-agent"]);
+      const result2 = {
+        subTasks: [
+          {
+            id: 1,
+            description: prompt,
+            files: [],
+            context: "",
+            dependencies: [],
+            metadata: this.createPlaceholderMetadata(
+              heuristics2,
+              domainAnalysis,
+              taskAnalysis,
+              prompt,
+              "single",
+              1,
+              0
+            )
+          }
+        ],
+        pendingSubTasks: [],
+        strategy: "single",
+        reasoning: "Only 1 agent requested, no splitting needed",
+        tokenAnalysis
+        // Include token analysis if available
+      };
+      result2.subTasks = attachMetadata(result2.subTasks, heuristics2, result2.strategy);
+      if (routingOptions.enableRouting) {
+        result2.routingDecisions = await this.generateRoutingDecisions(
+          result2.subTasks,
+          domainAnalysis,
+          routingOptions
+        );
+      }
+      this.validateCompleteExecution(result2);
+      return await this.finalizeSplitResult(result2, prompt, numAgents, splitOptions);
+    }
+    const coupling = this.analyzeCouplingSignals(heuristicPrompt);
+    if (coupling.coupled && numAgents > 1) {
+      debugLog(
+        `[TaskSplitter] Coupling signals detected (${coupling.signals.join(", ")}) \u2014 attempting provider semantic split`
+      );
+      const semanticResult = await this.tryProviderSemanticSplit(
+        heuristicPrompt,
+        prompt,
+        numAgents,
+        coupling,
+        tokenAnalysis
+      );
+      if (semanticResult) {
+        const heuristicsSemantic = /* @__PURE__ */ new Set([
+          "semantic-provider",
+          "coupling-detected",
+          ...coupling.signals.map((signal) => `coupling:${signal}`)
+        ]);
+        semanticResult.subTasks = attachMetadata(
+          semanticResult.subTasks,
+          heuristicsSemantic,
+          semanticResult.strategy
+        );
+        semanticResult.tokenAnalysis = tokenAnalysis;
+        if (routingOptions.enableRouting) {
+          semanticResult.routingDecisions = await this.generateRoutingDecisions(
+            semanticResult.subTasks,
+            domainAnalysis,
+            routingOptions
+          );
+        }
+        const hasDependencyEdges = semanticResult.subTasks.some(
+          (task) => task.dependencies.length > 0
+        );
+        if (splitOptions?.mode === "sequential" && !hasDependencyEdges) {
+          const batchedResult = this.applySequentialBatching(semanticResult, numAgents);
+          this.validateCompleteExecution(batchedResult);
+          return await this.finalizeSplitResult(batchedResult, prompt, numAgents, splitOptions);
+        }
+        this.validateCompleteExecution(semanticResult);
+        return await this.finalizeSplitResult(semanticResult, prompt, numAgents, splitOptions);
+      }
+      debugLog(
+        "[TaskSplitter] Coupled work could not be validated via provider semantic split \u2014 conservative unsplit"
+      );
+      const coupledHeuristics = /* @__PURE__ */ new Set([
+        "coupling-detected",
+        "semantic-fallback-unsplit",
+        ...coupling.signals.map((signal) => `coupling:${signal}`)
+      ]);
+      const unsplit = this.createSingleTask(
+        prompt,
+        `Coupled multi-file work detected (${coupling.signals.join(", ")}); conservatively keeping as single task after semantic split validation failure`
+      );
+      unsplit.subTasks = attachMetadata(unsplit.subTasks, coupledHeuristics, unsplit.strategy);
+      unsplit.tokenAnalysis = tokenAnalysis;
+      if (routingOptions.enableRouting) {
+        unsplit.routingDecisions = await this.generateRoutingDecisions(
+          unsplit.subTasks,
+          domainAnalysis,
+          routingOptions
+        );
+      }
+      this.validateCompleteExecution(unsplit);
+      return await this.finalizeSplitResult(unsplit, prompt, numAgents, splitOptions);
+    }
+    const fileSplit = this.splitByFiles(heuristicPrompt, numAgents);
+    const heuristicsFile = /* @__PURE__ */ new Set([
+      fileSplit.strategy === "focus-based" ? "focus-areas" : "file-based",
+      "work-unit-detection"
+    ]);
+    const fileSplitTasks = [...fileSplit.subTasks, ...fileSplit.pendingSubTasks.flat()];
+    const hasModuleInference = fileSplitTasks.some(
+      (task) => task.files.some((file) => !/\.[a-z0-9]+$/i.test(file))
+    );
+    if (hasModuleInference) {
+      heuristicsFile.add("module-inference");
+    }
+    const totalFileTasks = this.countTotalSubTasks(fileSplit);
+    if (totalFileTasks > 1) {
+      debugLog("[TaskSplitter] Strategy:", fileSplit.strategy);
+      debugLog("[TaskSplitter] Generated sub-tasks:");
+      fileSplit.subTasks.forEach((st, i) => {
+        debugLog(`  ${i + 1}. "${st.description}"`);
+        debugLog(`     Files: ${st.files.join(", ") || "none"}`);
+      });
+      if (fileSplit.pendingSubTasks.length > 0) {
+        const pendingCount = totalFileTasks - fileSplit.subTasks.length;
+        debugLog(
+          `  Pending batches: ${fileSplit.pendingSubTasks.length} (${pendingCount} additional task(s))`
+        );
+      }
+      const validSubTasks = fileSplit.subTasks.filter((st) => this.validateSubTask(st));
+      if (validSubTasks.length < fileSplit.subTasks.length) {
+        console.warn(
+          `[Task Splitter] Validation: ${validSubTasks.length}/${fileSplit.subTasks.length} valid sub-tasks`
+        );
+        debugLog(
+          "[DEBUG] Failed sub-tasks:",
+          fileSplit.subTasks.filter((st) => !this.validateSubTask(st))
+        );
+      }
+      if (validSubTasks.length === 0) {
+        console.warn(
+          "[Task Splitter] All file-based sub-tasks failed validation, falling back to single task"
+        );
+        debugLog("[DEBUG] Attempted file split:", fileSplit);
+        const fallbackHeuristics = /* @__PURE__ */ new Set([...heuristicsFile, "fallback-single"]);
+        const single = this.createSingleTask(
+          prompt,
+          "Generated sub-tasks failed validation, falling back to single task"
+        );
+        single.subTasks = attachMetadata(single.subTasks, fallbackHeuristics, single.strategy);
+        single.tokenAnalysis = tokenAnalysis;
+        if (routingOptions.enableRouting) {
+          single.routingDecisions = await this.generateRoutingDecisions(
+            single.subTasks,
+            domainAnalysis,
+            routingOptions
+          );
+        }
+        this.validateCompleteExecution(single);
+        return await this.finalizeSplitResult(single, prompt, numAgents, splitOptions);
+      }
+      const result2 = {
+        ...fileSplit,
+        subTasks: attachMetadata(validSubTasks, heuristicsFile, fileSplit.strategy),
+        tokenAnalysis
+        // Include token analysis if available
+      };
+      if (routingOptions.enableRouting) {
+        result2.routingDecisions = await this.generateRoutingDecisions(
+          result2.subTasks,
+          domainAnalysis,
+          routingOptions
+        );
+      }
+      if (splitOptions?.mode === "sequential") {
+        const batchedResult = this.applySequentialBatching(result2, numAgents);
+        this.validateCompleteExecution(batchedResult);
+        return await this.finalizeSplitResult(batchedResult, prompt, numAgents, splitOptions);
+      }
+      this.validateCompleteExecution(result2);
+      return await this.finalizeSplitResult(result2, prompt, numAgents, splitOptions);
+    }
+    const featureSplit = this.splitByFeatures(heuristicPrompt, numAgents);
+    const heuristicsFeature = /* @__PURE__ */ new Set(["feature-based"]);
+    const totalFeatureTasks = this.countTotalSubTasks(featureSplit);
+    if (totalFeatureTasks > 1) {
+      debugLog("[TaskSplitter] Strategy:", featureSplit.strategy);
+      debugLog("[TaskSplitter] Generated sub-tasks:");
+      featureSplit.subTasks.forEach((st, i) => {
+        debugLog(`  ${i + 1}. "${st.description}"`);
+      });
+      if (featureSplit.pendingSubTasks.length > 0) {
+        const pendingCount = totalFeatureTasks - featureSplit.subTasks.length;
+        debugLog(
+          `  Pending batches: ${featureSplit.pendingSubTasks.length} (${pendingCount} additional task(s))`
+        );
+      }
+      const validSubTasks = featureSplit.subTasks.filter((st) => this.validateSubTask(st));
+      if (validSubTasks.length < featureSplit.subTasks.length) {
+        console.warn(
+          `[Task Splitter] Validation: ${validSubTasks.length}/${featureSplit.subTasks.length} valid sub-tasks`
+        );
+        debugLog(
+          "[DEBUG] Failed sub-tasks:",
+          featureSplit.subTasks.filter((st) => !this.validateSubTask(st))
+        );
+      }
+      if (validSubTasks.length === 0) {
+        console.warn(
+          "[Task Splitter] All feature-based sub-tasks failed validation, falling back to single task"
+        );
+        debugLog("[DEBUG] Attempted feature split:", featureSplit);
+        const fallbackHeuristics = /* @__PURE__ */ new Set([...heuristicsFeature, "fallback-single"]);
+        const single = this.createSingleTask(
+          prompt,
+          "Generated sub-tasks failed validation, falling back to single task"
+        );
+        single.subTasks = attachMetadata(single.subTasks, fallbackHeuristics, single.strategy);
+        single.tokenAnalysis = tokenAnalysis;
+        if (routingOptions.enableRouting) {
+          single.routingDecisions = await this.generateRoutingDecisions(
+            single.subTasks,
+            domainAnalysis,
+            routingOptions
+          );
+        }
+        this.validateCompleteExecution(single);
+        return await this.finalizeSplitResult(single, prompt, numAgents, splitOptions);
+      }
+      const result2 = {
+        ...featureSplit,
+        subTasks: attachMetadata(validSubTasks, heuristicsFeature, featureSplit.strategy),
+        tokenAnalysis
+        // Include token analysis if available
+      };
+      if (routingOptions.enableRouting) {
+        result2.routingDecisions = await this.generateRoutingDecisions(
+          result2.subTasks,
+          domainAnalysis,
+          routingOptions
+        );
+      }
+      if (splitOptions?.mode === "sequential") {
+        const batchedResult = this.applySequentialBatching(result2, numAgents);
+        this.validateCompleteExecution(batchedResult);
+        return await this.finalizeSplitResult(batchedResult, prompt, numAgents, splitOptions);
+      }
+      this.validateCompleteExecution(result2);
+      return await this.finalizeSplitResult(result2, prompt, numAgents, splitOptions);
+    }
+    debugLog("[TaskSplitter] No splitting strategy applicable, returning single task");
+    const heuristics = /* @__PURE__ */ new Set(["single-fallback"]);
+    const result = this.createSingleTask(
+      prompt,
+      "Task cannot be split - too atomic or no clear work units"
+    );
+    result.subTasks = attachMetadata(result.subTasks, heuristics, result.strategy);
+    result.tokenAnalysis = tokenAnalysis;
+    if (routingOptions.enableRouting) {
+      result.routingDecisions = await this.generateRoutingDecisions(
+        result.subTasks,
+        domainAnalysis,
+        routingOptions
+      );
+    }
+    this.validateCompleteExecution(result);
+    return await this.finalizeSplitResult(result, prompt, numAgents, splitOptions);
+  }
+  /**
+   * Split task by files mentioned in prompt
+   *
+   * Example:
+   *   "Generate tests for auth.ts, config.ts, metadata.ts"
+   *   → 3 sub-tasks, one per file
+   */
+  splitByFiles(prompt, maxAgents) {
+    const focusPattern = /\bfocus(?:ing)?\s+on\s+(?:testing\s+)?(.+)/i;
+    const focusMatch = prompt.match(focusPattern);
+    if (focusMatch) {
+      const focusText = focusMatch[1] || "";
+      const focusAreas = this.extractFocusAreas(focusText);
+      if (focusAreas.length > 1) {
+        const context2 = this.buildContextFromFocus(prompt, focusText || "");
+        return this.createFocusBasedSubTasks(context2, focusAreas, maxAgents);
+      }
+    }
+    const fileRegex = /([a-zA-Z0-9_\-/]+\.(?:ts|js|tsx|jsx|py|java|go|rs|cpp|c|h))\b/g;
+    const matches = [...prompt.matchAll(fileRegex)];
+    const files = matches.map((m) => m[1]?.trim() || "");
+    let modules = [];
+    let moduleCountWasCapped = false;
+    const hasColonPattern = /^(.+?):\s*(.+)$/.test(prompt);
+    if (!hasColonPattern) {
+      modules = this.extractExplicitModuleList(prompt);
+      if (files.length > 0) {
+        modules = [...modules, ...this.extractInlineModulesWhenFilesPresent(prompt)];
+      } else if (modules.length === 0) {
+        modules = this.extractInstructionPrefixedModuleList(prompt);
+      }
+      modules = modules.filter((moduleName) => {
+        return !files.some((f) => f.startsWith(`${moduleName}.`));
+      });
+    }
+    if (files.length === 0 && modules.length > maxAgents * 2) {
+      moduleCountWasCapped = true;
+      console.warn(
+        `[Task Splitter] Suspicious module detection: ${modules.length} modules for ${maxAgents} agents. Capping to ${maxAgents * 2}.`
+      );
+      modules = modules.slice(0, maxAgents * 2);
+    }
+    const allWorkUnits = [...files, ...modules].filter((v, i, a) => a.indexOf(v) === i);
+    if (allWorkUnits.length === 0) {
+      return {
+        subTasks: [],
+        pendingSubTasks: [],
+        strategy: "file-based",
+        reasoning: "No files or modules found in prompt"
+      };
+    }
+    const moduleSet = new Set(modules);
+    const fullPrompt = prompt.trim();
+    const context = this.extractContext(prompt, allWorkUnits);
+    const { firstBatch, pendingBatches } = this.buildBatchedSubTasks(
+      allWorkUnits,
+      maxAgents,
+      (unit, id) => ({
+        id,
+        description: moduleSet.has(unit) ? fullPrompt ? `${fullPrompt} Focus specifically on ${unit}.` : unit : context ? `${context} for ${unit}` : unit,
+        files: [unit],
+        context: moduleSet.has(unit) ? fullPrompt : context,
+        dependencies: []
+      })
+    );
+    const sanitized = this.sanitizeBatches(firstBatch, pendingBatches);
+    const baseReasoning = allWorkUnits.length < maxAgents ? `Found ${allWorkUnits.length} file(s)/module(s) in prompt; requested ${maxAgents} agents but only ${allWorkUnits.length} work unit(s) were detected` : `Found ${allWorkUnits.length} file(s)/module(s) in prompt`;
+    const reasoning = moduleCountWasCapped ? `${baseReasoning} (module detection capped at ${maxAgents * 2} to avoid over-splitting)` : baseReasoning;
+    const result = {
+      subTasks: sanitized.subTasks,
+      pendingSubTasks: sanitized.pendingSubTasks,
+      strategy: "file-based",
+      reasoning
+    };
+    return result;
+  }
+  extractExplicitModuleList(prompt) {
+    const modules = /* @__PURE__ */ new Set();
+    const addFromList = (listText) => {
+      const parsed = this.parseModuleListCandidate(listText);
+      if (!parsed) return;
+      for (const item of parsed) {
+        modules.add(item);
+      }
+    };
+    const labeledListPattern = /\b(?:modules?|files?)\s*:\s*([^\n]+)/gi;
+    for (const match of prompt.matchAll(labeledListPattern)) {
+      addFromList(match[1] || "");
+    }
+    const scopedListPattern = /\b(?:for|in|on|across|within)\s+((?:[a-z][a-z0-9_-]{2,}\s*,\s*)+[a-z][a-z0-9_-]{2,}(?:\s*,?\s*and\s+[a-z][a-z0-9_-]{2,})?)(?=\s*(?:$|[.;:!?]))/gi;
+    for (const match of prompt.matchAll(scopedListPattern)) {
+      addFromList(match[1] || "");
+    }
+    const trimmed = prompt.trim();
+    const standaloneListPattern = /^(?:[a-z][a-z0-9_-]{2,}\s*,\s*)+[a-z][a-z0-9_-]{2,}(?:\s*,?\s*and\s+[a-z][a-z0-9_-]{2,})?$/i;
+    if (standaloneListPattern.test(trimmed)) {
+      addFromList(trimmed);
+    }
+    return [...modules];
+  }
+  extractInlineModulesWhenFilesPresent(prompt) {
+    if (!prompt.includes(",")) return [];
+    const modules = /* @__PURE__ */ new Set();
+    const parts = prompt.split(/\s*,\s*/).map((part) => part.trim());
+    for (const part of parts) {
+      const normalized = part.replace(/^[`"'([{]+|[`"')\]}.!?:;]+$/g, "").trim();
+      if (/^[a-z][a-z0-9_-]{2,}$/i.test(normalized)) {
+        modules.add(normalized);
+      }
+    }
+    return [...modules];
+  }
+  extractInstructionPrefixedModuleList(prompt) {
+    if (!prompt.includes(",")) return [];
+    const parts = prompt.split(/\s*,\s*/).map((part) => part.replace(/^[`"'([{]+|[`"')\]}.!?:;]+$/g, "").trim()).filter((part) => part.length > 0);
+    if (parts.length < 2) return [];
+    const allowedLeadVerbs = /* @__PURE__ */ new Set([
+      "test",
+      "generate",
+      "create",
+      "update",
+      "refactor",
+      "review",
+      "analyze",
+      "audit",
+      "fix",
+      "implement",
+      "add",
+      "write",
+      "check",
+      "validate",
+      "verify",
+      "improve",
+      "optimize"
+    ]);
+    const firstMatch = parts[0]?.match(/^([a-z]+)\s+([a-z][a-z0-9_-]{2,})$/i);
+    if (!firstMatch || !allowedLeadVerbs.has(firstMatch[1]?.toLowerCase() || "")) {
+      return [];
+    }
+    const modules = [firstMatch[2] || ""];
+    for (const part of parts.slice(1)) {
+      const normalized = part.replace(/^and\s+/i, "").trim();
+      if (!/^[a-z][a-z0-9_-]{2,}$/i.test(normalized)) {
+        return [];
+      }
+      modules.push(normalized);
+    }
+    return modules.filter((moduleName) => moduleName.length > 0);
+  }
+  parseModuleListCandidate(listText) {
+    const normalized = listText.replace(/\s*,\s*and\s+/gi, ", ").replace(/\s+and\s+/gi, ", ").trim();
+    if (!normalized.includes(",")) return null;
+    const parts = normalized.split(/\s*,\s*/).map((part) => part.replace(/^[`"'([{]+|[`"')\]}.!?:;]+$/g, "").trim()).filter((part) => part.length > 0);
+    if (parts.length < 2) return null;
+    if (!parts.every((part) => /^[a-z][a-z0-9_-]{2,}$/i.test(part))) {
+      return null;
+    }
+    return parts;
+  }
+  /**
+   * Split task by features/functionality
+   *
+   * Example:
+   *   "Implement authentication: login, signup, password reset, session management"
+   *   → 4 sub-tasks
+   */
+  splitByFeatures(prompt, maxAgents) {
+    const separatorIndex = this.findFeatureListSeparator(prompt);
+    if (separatorIndex >= 0) {
+      const baseTask = prompt.slice(0, separatorIndex).trim();
+      const featureList = prompt.slice(separatorIndex + 1);
+      const features = this.parseBoundedFeatureList(featureList);
+      if (baseTask && features.length > 1) {
+        const { firstBatch, pendingBatches } = this.buildBatchedSubTasks(
+          features,
+          maxAgents,
+          (feature, id) => ({
+            id,
+            description: `${baseTask}: ${feature}`,
+            files: [],
+            context: baseTask,
+            dependencies: []
+          })
+        );
+        const sanitized = this.sanitizeBatches(firstBatch, pendingBatches);
+        const result = {
+          subTasks: sanitized.subTasks,
+          pendingSubTasks: sanitized.pendingSubTasks,
+          strategy: "feature-based",
+          reasoning: features.length < maxAgents ? `Found ${features.length} feature(s) in colon-separated list; requested ${maxAgents} agents but only ${features.length} work unit(s) were detected` : `Found ${features.length} feature(s) in colon-separated list`
+        };
+        return result;
+      }
+    }
+    return {
+      subTasks: [],
+      pendingSubTasks: [],
+      strategy: "feature-based",
+      reasoning: "No clear feature list found"
+    };
+  }
+  findFeatureListSeparator(prompt) {
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    for (let i = 0; i < prompt.length; i += 1) {
+      const char = prompt[i];
+      if (char === "(") parenDepth += 1;
+      else if (char === ")" && parenDepth > 0) parenDepth -= 1;
+      else if (char === "[") bracketDepth += 1;
+      else if (char === "]" && bracketDepth > 0) bracketDepth -= 1;
+      else if (char === "{") braceDepth += 1;
+      else if (char === "}" && braceDepth > 0) braceDepth -= 1;
+      else if (char === ":" && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  parseBoundedFeatureList(featureList) {
+    const features = featureList.split(/\s*,\s*|\s+and\s+/i).map((feature) => feature.trim()).filter((feature) => feature.length > 0);
+    if (features.length < 2) return [];
+    if (!features.every((feature) => this.isBoundedFeatureItem(feature))) return [];
+    return features;
+  }
+  isBoundedFeatureItem(feature) {
+    const normalized = feature.replace(/^[`"'([{]+|[`"')\]}.!?:;]+$/g, "").trim();
+    if (!normalized) return false;
+    if (normalized.length > 56) return false;
+    const words = normalized.split(/\s+/).filter((word) => word.length > 0);
+    if (words.length > 6) return false;
+    if (/[.!?;]/.test(normalized)) return false;
+    if (!this.hasBalancedDelimiters(normalized)) return false;
+    if (this.containsCodeLikeToken(normalized)) return false;
+    const firstWord = words[0]?.toLowerCase() ?? "";
+    const imperativeLeads = /* @__PURE__ */ new Set([
+      "add",
+      "assert",
+      "capture",
+      "check",
+      "compute",
+      "create",
+      "do",
+      "emit",
+      "ensure",
+      "fix",
+      "implement",
+      "keep",
+      "raise",
+      "return",
+      "run",
+      "update",
+      "validate",
+      "verify",
+      "write"
+    ]);
+    if (imperativeLeads.has(firstWord)) return false;
+    return /^[a-z0-9][a-z0-9_\- /]+$/i.test(normalized);
+  }
+  hasBalancedDelimiters(text) {
+    const pairs = /* @__PURE__ */ new Map([
+      [")", "("],
+      ["]", "["],
+      ["}", "{"]
+    ]);
+    const stack = [];
+    for (const char of text) {
+      if (char === "(" || char === "[" || char === "{") {
+        stack.push(char);
+      } else if (pairs.has(char)) {
+        if (stack.pop() !== pairs.get(char)) return false;
+      }
+    }
+    return stack.length === 0;
+  }
+  containsCodeLikeToken(text) {
+    return /[`=<>]|->|::/.test(text) || /\b(?:cargo|npm|pnpm|yarn|python|pytest|unittest|go\s+test|make)\b/i.test(text);
+  }
+  /**
+   * Extract shared context from prompt, removing file/module references
+   *
+   * Example:
+   *   Input: "Generate tests for auth.ts, config.ts, metadata.ts"
+   *   Output: "Generate tests"
+   */
+  extractContext(prompt, workUnits) {
+    const normalizedPrompt = prompt.replace(/\s+/g, " ").trim();
+    if (!normalizedPrompt) {
+      return "";
+    }
+    const colonSplit = normalizedPrompt.match(/^(.+?):\s*(.+)$/);
+    if (colonSplit) {
+      const left = colonSplit[1]?.trim() ?? "";
+      const right = colonSplit[2]?.toLowerCase() ?? "";
+      const referencesKnownUnit = workUnits.some((unit) => right.includes(unit.toLowerCase()));
+      if (left.length > 0 && referencesKnownUnit) {
+        return left;
+      }
+    }
+    let firstUnitIndex = Number.POSITIVE_INFINITY;
+    for (const unit of workUnits) {
+      const idx = normalizedPrompt.toLowerCase().indexOf(unit.toLowerCase());
+      if (idx >= 0 && idx < firstUnitIndex) {
+        firstUnitIndex = idx;
+      }
+    }
+    if (Number.isFinite(firstUnitIndex) && firstUnitIndex > 0) {
+      const candidate = normalizedPrompt.slice(0, firstUnitIndex);
+      const cleaned = candidate.replace(/[,:;]\s*$/g, "").replace(/\b(?:for|in|on|across|within|and)\s*$/i, "").replace(/\s+/g, " ").trim();
+      if (cleaned.length > 0) {
+        return cleaned;
+      }
+    }
+    const prepositionPrefix = normalizedPrompt.match(/^(.+?)\b(?:for|in|on|across|within)\b\s+/i);
+    if (prepositionPrefix?.[1]) {
+      const cleaned = prepositionPrefix[1].trim();
+      if (cleaned.length > 0) {
+        return cleaned;
+      }
+    }
+    return normalizedPrompt;
+  }
+  buildBatchedSubTasks(workUnits, maxAgents, builder) {
+    if (maxAgents <= 0 || workUnits.length === 0) {
+      return { firstBatch: [], pendingBatches: [] };
+    }
+    const batches = [];
+    let nextId = 1;
+    for (let i = 0; i < workUnits.length; i += maxAgents) {
+      const slice = workUnits.slice(i, i + maxAgents);
+      if (slice.length === 0) {
+        continue;
+      }
+      const batchIndex = batches.length;
+      const batch = slice.map((unit) => builder(unit, nextId++, batchIndex));
+      batches.push(batch);
+    }
+    const [firstBatch = [], ...pendingBatches] = batches;
+    return { firstBatch, pendingBatches };
+  }
+  sanitizeBatches(firstBatch, pendingBatches) {
+    const batches = [firstBatch, ...pendingBatches];
+    const validBatches = [];
+    for (const batch of batches) {
+      const valid = batch.filter((task) => this.validateSubTask(task));
+      if (valid.length > 0) {
+        validBatches.push(valid);
+      }
+    }
+    if (validBatches.length === 0) {
+      return { subTasks: [], pendingSubTasks: [] };
+    }
+    let nextId = 1;
+    const reindexed = validBatches.map(
+      (batch) => batch.map((task) => ({
+        ...task,
+        id: nextId++
+      }))
+    );
+    const [subTasks = [], ...pendingSubTasks] = reindexed;
+    return { subTasks, pendingSubTasks };
+  }
+  countTotalSubTasks(result) {
+    const pendingCount = result.pendingSubTasks.reduce((sum, batch) => sum + batch.length, 0);
+    return result.subTasks.length + pendingCount;
+  }
+  /**
+   * Extract focus areas from a focus clause
+   *
+   * Example:
+   *   "lock acquisition, release, timeout scenarios, and edge cases"
+   *   → ["lock acquisition", "release", "timeout scenarios", "edge cases"]
+   */
+  extractFocusAreas(focusText) {
+    const areas = focusText.split(/,\s*(?:and\s+)?|\s+and\s+/i).map((a) => a.trim()).filter((a) => a.length > 0);
+    return areas;
+  }
+  /**
+   * Build context by removing focus clause from prompt
+   *
+   * Example:
+   *   Input: "Generate tests for X. Focus on A, B, C"
+   *   Output: "Generate tests for X"
+   */
+  buildContextFromFocus(prompt, _focusText) {
+    const focusPattern = /\bfocus(?:ing)?\s+on\s+(?:testing\s+)?(.+)/i;
+    const context = prompt.replace(focusPattern, "").trim();
+    return context.replace(/[,.\s]+$/, "");
+  }
+  /**
+   * Create sub-tasks from focus areas
+   */
+  createFocusBasedSubTasks(context, focusAreas, maxAgents) {
+    const { firstBatch, pendingBatches } = this.buildBatchedSubTasks(
+      focusAreas,
+      maxAgents,
+      (area, id) => ({
+        id,
+        description: `${context}. Focus on testing ${area}`,
+        files: [],
+        context,
+        dependencies: []
+      })
+    );
+    const sanitized = this.sanitizeBatches(firstBatch, pendingBatches);
+    return {
+      subTasks: sanitized.subTasks,
+      pendingSubTasks: sanitized.pendingSubTasks,
+      // Mark this strategy explicitly as focus-based so callers can
+      // set appropriate heuristics (e.g., include 'focus-areas').
+      strategy: "focus-based",
+      reasoning: focusAreas.length < maxAgents ? `Found ${focusAreas.length} focus area(s) in prompt; requested ${maxAgents} agents but only ${focusAreas.length} work unit(s) were detected` : `Found ${focusAreas.length} focus area(s) in prompt`
+    };
+  }
+  /**
+   * Validate a sub-task for malformations
+   *
+   * Checks for common issues like:
+   * - Mangled context (e.g., "in .", "for .")
+   * - Trailing incomplete phrases
+   * - Too short descriptions (but allow feature-based tasks like "Add: feature1")
+   */
+  validateSubTask(subTask) {
+    const desc = subTask.description;
+    const issues = [
+      desc.includes(" . "),
+      // Mangled context: "in ."
+      desc.includes(" for ."),
+      // Mangled target: "for ."
+      desc.trim().endsWith(" for"),
+      // Trailing "for"
+      desc.trim().endsWith(" in"),
+      // Trailing "in"
+      desc.length < 5
+      // Too short (relaxed from 10 to allow "Add: X")
+      // Removed word count check - feature-based tasks like "Implement: login" are valid with 2 words
+    ];
+    const isValid = !issues.some((issue) => issue);
+    if (!isValid) {
+      console.warn("[Task Splitter] Invalid sub-task rejected:", desc);
+      debugLog("[DEBUG] Validation failures:", {
+        hasMangled: desc.includes(" . "),
+        hasMangledTarget: desc.includes(" for ."),
+        trailingFor: desc.trim().endsWith(" for"),
+        trailingIn: desc.trim().endsWith(" in"),
+        tooShort: desc.length < 5
+      });
+    }
+    return isValid;
+  }
+  async finalizeSplitResult(result, prompt, numAgents, splitOptions) {
+    this.emitSubTaskDedupTelemetry(result);
+    await this.runLlmSplitterShadow(prompt, numAgents, result, splitOptions);
+    return result;
+  }
+  getAllSubTasks(result) {
+    return [...result.subTasks, ...result.pendingSubTasks.flat()];
+  }
+  tokenizeForSimilarity(text) {
+    return new Set(
+      text.toLowerCase().split(/[^a-z0-9]+/g).map((token) => token.trim()).filter((token) => token.length > 0)
+    );
+  }
+  calculateJaccardSimilarity(a, b) {
+    if (a.size === 0 && b.size === 0) return 1;
+    if (a.size === 0 || b.size === 0) return 0;
+    let intersection = 0;
+    for (const token of a) {
+      if (b.has(token)) {
+        intersection += 1;
+      }
+    }
+    const union = a.size + b.size - intersection;
+    return union > 0 ? intersection / union : 0;
+  }
+  emitSubTaskDedupTelemetry(result) {
+    const subTasks = this.getAllSubTasks(result);
+    if (subTasks.length < 2) return;
+    for (let i = 0; i < subTasks.length; i += 1) {
+      const left = subTasks[i];
+      if (!left) continue;
+      const leftTokens = this.tokenizeForSimilarity(left.description);
+      for (let j = i + 1; j < subTasks.length; j += 1) {
+        const right = subTasks[j];
+        if (!right) continue;
+        const rightTokens = this.tokenizeForSimilarity(right.description);
+        const similarity = this.calculateJaccardSimilarity(leftTokens, rightTokens);
+        if (similarity > SUBTASK_DEDUP_THRESHOLD) {
+          emitCustomWarning(
+            "WARN" /* WARN */,
+            "validation" /* VALIDATION */,
+            "Task splitter detected potential duplicate subtasks",
+            {
+              subsystem: "orchestrator",
+              executionPhase: "setup"
+            },
+            {
+              metadata: {
+                threshold: SUBTASK_DEDUP_THRESHOLD,
+                similarity,
+                pair: {
+                  left: {
+                    id: left.id,
+                    description: left.description,
+                    files: left.files
+                  },
+                  right: {
+                    id: right.id,
+                    description: right.description,
+                    files: right.files
+                  }
+                }
+              }
+            }
+          );
+        }
+      }
+    }
+  }
+  shouldRunLlmShadow(splitOptions) {
+    if (splitOptions?.llmShadow === true) return true;
+    return readEnv(POETIC_SPLITTER_SHADOW).value ?? false;
+  }
+  createSplitterShadowPrompt(prompt, numAgents) {
+    return `Split this task into up to ${numAgents} coding subtasks.
+
+Task:
+${prompt}
+
+Return ONLY a pure JSON object (optional surrounding whitespace). No markdown fences, no prose.
+Schema:
+{
+  "subtasks": [
+    {
+      "id": 1,
+      "description": "string",
+      "targetFiles": ["optional/path.ts"],
+      "dependencies": [],
+      "boundary": "short boundary note"
+    }
+  ]
+}
+
+Rules:
+- ids must be unique positive integers.
+- dependencies lists prerequisite subtask ids that must complete first.
+- Ordered work MUST declare real dependency edges (dependents list prerequisite ids).
+- Keep subtasks distinct with non-overlapping targetFiles.
+- Focus on executable implementation work.
+- Do not include markdown or prose outside JSON.`;
+  }
+  /**
+   * Strict JSON object parse: accept only a pure JSON object with optional
+   * surrounding whitespace. Prose wrappers, markdown fences, and substring
+   * extraction from mixed text are malformed.
+   */
+  parseStrictJsonObject(raw, context) {
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+      return null;
+    }
+    try {
+      const parsed = parseJsonWithContext(trimmed, context);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  parseSplitterShadowResult(raw) {
+    const parsed = this.parseStrictJsonObject(raw, "TaskSplitter shadow split response");
+    if (parsed === null) return null;
+    const subtasksRaw = parsed.subtasks;
+    if (!Array.isArray(subtasksRaw)) return null;
+    const subtasks = [];
+    for (const item of subtasksRaw) {
+      if (typeof item !== "object" || item === null) return null;
+      const record = item;
+      if (typeof record.description !== "string" || record.description.trim().length === 0) {
+        return null;
+      }
+      const targetFiles = Array.isArray(record.targetFiles) ? record.targetFiles.filter((entry) => typeof entry === "string") : void 0;
+      let dependencies;
+      if (Array.isArray(record.dependencies)) {
+        const parsedDeps = [];
+        for (const entry of record.dependencies) {
+          if (typeof entry !== "number" || !Number.isInteger(entry)) {
+            return null;
+          }
+          parsedDeps.push(entry);
+        }
+        dependencies = parsedDeps;
+      }
+      const id = typeof record.id === "number" && Number.isInteger(record.id) ? record.id : void 0;
+      subtasks.push({
+        id,
+        description: record.description.trim(),
+        targetFiles,
+        dependencies,
+        boundary: typeof record.boundary === "string" ? record.boundary : void 0
+      });
+    }
+    return { subtasks };
+  }
+  /**
+   * Detect cross-file renames, shared contracts, and other coupling invariants.
+   * Scans the full stripped prompt — no fixed 8K truncation window.
+   */
+  analyzeCouplingSignals(prompt) {
+    const signals = [];
+    const text = prompt;
+    const filePaths = this.extractFilePathTokens(text);
+    const renamePatterns = [
+      { name: "rename-to", pattern: /\brename\s+(?:file\s+)?(\S+)\s+to\s+(\S+)/i },
+      { name: "rename-arrow", pattern: /\brename\s+(\S+)\s*->\s*(\S+)/i },
+      { name: "move-to", pattern: /\b(?:move|mv)\s+(\S+\.\w+)\s+to\s+(\S+)/i },
+      {
+        name: "from-to-paths",
+        pattern: /\bfrom\s+[`'"]?([^\s`'"]+\.[a-zA-Z0-9]+)[`'"]?\s+to\s+[`'"]?([^\s`'"]+\.[a-zA-Z0-9]+)/i
+      },
+      {
+        name: "rename-from-to",
+        pattern: /\brename\s+from\s+(\S+)\s+to\s+(\S+)/i
+      }
+    ];
+    for (const { name, pattern } of renamePatterns) {
+      if (pattern.test(text)) {
+        signals.push(name);
+      }
+    }
+    if (/\bshared\s+(?:types?|contracts?|interfaces?|schemas?|models?)\b/i.test(text) || /\bshar(?:e|es|ed)\b[\s\S]{0,48}\b(?:types?|contracts?|interfaces?|schemas?|models?)\b/i.test(
+      text
+    )) {
+      signals.push("shared-types");
+    }
+    if (/\b(?:type|interface|contract|schema)\b[\s\S]{0,80}\b(?:shared|across|between)\b/i.test(text)) {
+      signals.push("shared-contract-span");
+    }
+    if (/\bcross[- ]file\b/i.test(text)) {
+      signals.push("cross-file");
+    }
+    if (/\b(?:across|between)\s+(?:all\s+)?(?:the\s+)?(?:files|modules)\b/i.test(text)) {
+      signals.push("across-files");
+    }
+    if (/\bkeep\b[\s\S]{0,80}\bin\s+sync\b/i.test(text)) {
+      signals.push("keep-in-sync");
+    }
+    if (/\bmust\s+(?:agree|match|stay\s+consistent)\b/i.test(text)) {
+      signals.push("must-agree");
+    }
+    if (/\b(?:api|endpoint)(?:\s+and\s+|\s*\+\s*)(?:impl(?:ementation)?|handler|service)\b/i.test(
+      text
+    ) || /\bimplementation\s+and\s+(?:the\s+)?(?:api|interface|contract)\b/i.test(text)) {
+      signals.push("api-impl-pair");
+    }
+    if (/\bupdate\s+all\s+(?:call\s*sites?|references|imports|usages)\b/i.test(text)) {
+      signals.push("update-all-references");
+    }
+    if (/\bbreaking\s+change\b/i.test(text)) {
+      signals.push("breaking-change");
+    }
+    if (filePaths.length > 1 && /\b(?:depends?\s+on|prerequisite|must\s+(?:happen|run|complete)\s+(?:before|after))\b/i.test(
+      text
+    )) {
+      signals.push("ordered-dependency");
+    }
+    if (filePaths.length > 1 && /\b(?:invariant|consistency|atomic(?:ally)?)\b/i.test(text)) {
+      signals.push("cross-file-invariant");
+    }
+    return {
+      coupled: signals.length > 0,
+      signals: [...new Set(signals)],
+      filePaths
+    };
+  }
+  extractFilePathTokens(prompt) {
+    const matches = prompt.match(FILE_PATH_TOKEN_REGEX) ?? [];
+    const unique = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const match of matches) {
+      const canonical = this.canonicalizeOwnedPath(match);
+      if (!canonical || seen.has(canonical)) continue;
+      seen.add(canonical);
+      unique.push(canonical);
+    }
+    return unique;
+  }
+  /**
+   * Independent mechanical multi-file lists (e.g. "generate tests for a.ts, b.ts")
+   * may still use lexical file-based splitting.
+   */
+  hasIndependentMechanicalFileList(prompt) {
+    const files = this.extractFilePathTokens(prompt);
+    if (files.length > 1) return true;
+    const modules = this.extractExplicitModuleList(prompt);
+    if (modules.length > 1) return true;
+    const instructionModules = this.extractInstructionPrefixedModuleList(prompt);
+    return instructionModules.length > 1;
+  }
+  /**
+   * Canonicalize a path for ownership comparison.
+   * Rejects workspace escapes, absolute paths, and ambiguous Windows drive-relative forms.
+   * Treats `./a.ts` and `a.ts` as the same ownership key.
+   */
+  canonicalizeOwnedPath(filePath) {
+    const raw = filePath.trim();
+    if (!raw || raw.includes("\0")) return null;
+    if (raw.startsWith("\\\\") || raw.startsWith("//")) return null;
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw)) return null;
+    if (raw.startsWith("/")) return null;
+    if (/^[a-zA-Z]:[\\/]/.test(raw)) return null;
+    if (/^[a-zA-Z]:[^\\/]/.test(raw)) return null;
+    const normalized = raw.replace(/\\/g, "/");
+    const segments = normalized.split("/");
+    const stack = [];
+    for (const segment of segments) {
+      if (segment === "" || segment === ".") continue;
+      if (segment === "..") {
+        if (stack.length === 0) return null;
+        stack.pop();
+        continue;
+      }
+      stack.push(segment);
+    }
+    if (stack.length === 0) return null;
+    return stack.join("/");
+  }
+  validateSemanticSplitGraph(subTasks) {
+    if (subTasks.length === 0) {
+      return { valid: false, reason: "empty-subtasks" };
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (const task of subTasks) {
+      if (!Number.isInteger(task.id) || task.id <= 0) {
+        return { valid: false, reason: `invalid-id:${task.id}` };
+      }
+      if (ids.has(task.id)) {
+        return { valid: false, reason: `duplicate-id:${task.id}` };
+      }
+      ids.add(task.id);
+    }
+    for (const task of subTasks) {
+      for (const depId of task.dependencies) {
+        if (!Number.isInteger(depId) || depId <= 0) {
+          return { valid: false, reason: `invalid-dependency:${task.id}->${depId}` };
+        }
+        if (!ids.has(depId)) {
+          return { valid: false, reason: `missing-dependency:${task.id}->${depId}` };
+        }
+        if (depId === task.id) {
+          return { valid: false, reason: `self-dependency:${task.id}` };
+        }
+      }
+    }
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const task of subTasks) {
+      adjacency.set(task.id, [...task.dependencies]);
+    }
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = /* @__PURE__ */ new Map();
+    for (const id of ids) color.set(id, WHITE);
+    const hasCycle = (node) => {
+      color.set(node, GRAY);
+      for (const dep of adjacency.get(node) ?? []) {
+        const depColor = color.get(dep) ?? WHITE;
+        if (depColor === GRAY) return true;
+        if (depColor === WHITE && hasCycle(dep)) return true;
+      }
+      color.set(node, BLACK);
+      return false;
+    };
+    for (const id of ids) {
+      if ((color.get(id) ?? WHITE) === WHITE && hasCycle(id)) {
+        return { valid: false, reason: "cyclic-dependencies" };
+      }
+    }
+    const ownership = /* @__PURE__ */ new Map();
+    for (const task of subTasks) {
+      for (const file of task.files) {
+        const canonical = this.canonicalizeOwnedPath(file);
+        if (canonical === null) {
+          return { valid: false, reason: `unsafe-path:${file}` };
+        }
+        const owner = ownership.get(canonical);
+        if (owner !== void 0 && owner !== task.id) {
+          return {
+            valid: false,
+            reason: `overlapping-ownership:${canonical}:${owner},${task.id}`
+          };
+        }
+        ownership.set(canonical, task.id);
+      }
+    }
+    return { valid: true };
+  }
+  materializeSemanticSubTasks(parsed, originalPrompt) {
+    if (parsed.subtasks.length === 0) return null;
+    const hasExplicitIds = parsed.subtasks.every(
+      (task) => typeof task.id === "number" && Number.isInteger(task.id)
+    );
+    const subTasks = parsed.subtasks.map((task, index) => {
+      const id = hasExplicitIds ? task.id : index + 1;
+      const files = (task.targetFiles ?? []).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+      return {
+        id,
+        description: task.description,
+        files,
+        context: task.boundary ?? originalPrompt,
+        dependencies: Array.isArray(task.dependencies) ? [...task.dependencies] : []
+      };
+    });
+    if (!hasExplicitIds) {
+      for (const task of subTasks) {
+        if (task.dependencies.length > 0) {
+          return null;
+        }
+      }
+    }
+    const validation = this.validateSemanticSplitGraph(subTasks);
+    if (!validation.valid) {
+      debugLog(`[TaskSplitter] Semantic split graph rejected: ${validation.reason}`);
+      return null;
+    }
+    return subTasks;
+  }
+  async tryProviderSemanticSplit(heuristicPrompt, originalPrompt, numAgents, coupling, tokenAnalysis) {
+    try {
+      const model = resolveSplitterModel(void 0, process.cwd()).value;
+      const providerPrompt = heuristicPrompt.length > 0 ? heuristicPrompt : originalPrompt;
+      const raw = await this.splitterShadowRunner({
+        prompt: providerPrompt,
+        numAgents,
+        model
+      });
+      const parsed = this.parseSplitterShadowResult(raw);
+      if (!parsed || parsed.subtasks.length === 0) {
+        debugLog("[TaskSplitter] Provider semantic split returned malformed/empty JSON");
+        return null;
+      }
+      const subTasks = this.materializeSemanticSubTasks(parsed, originalPrompt);
+      if (!subTasks || subTasks.length === 0) {
+        return null;
+      }
+      const hasDeps = subTasks.some((task) => task.dependencies.length > 0);
+      if (hasDeps || subTasks.length <= numAgents) {
+        return {
+          subTasks,
+          pendingSubTasks: [],
+          strategy: "semantic",
+          reasoning: hasDeps ? `Provider semantic split produced ${subTasks.length} sub-tasks with dependency edges (signals: ${coupling.signals.join(", ")})` : `Provider semantic split produced ${subTasks.length} sub-tasks with validated ownership (signals: ${coupling.signals.join(", ")})`,
+          tokenAnalysis
+        };
+      }
+      const firstBatch = subTasks.slice(0, numAgents);
+      const remainder = subTasks.slice(numAgents);
+      const pendingSubTasks = [];
+      for (let i = 0; i < remainder.length; i += numAgents) {
+        pendingSubTasks.push(remainder.slice(i, i + numAgents));
+      }
+      return {
+        subTasks: firstBatch,
+        pendingSubTasks,
+        strategy: "semantic",
+        reasoning: `Provider semantic split produced ${subTasks.length} sub-tasks (signals: ${coupling.signals.join(", ")})`,
+        tokenAnalysis
+      };
+    } catch (error) {
+      debugLog(
+        `[TaskSplitter] Provider semantic split failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  defaultSplitterShadowRunner = async (input) => {
+    const { registry } = await import("./registry-YODFY77A.js");
+    const provider = resolveDefaultProvider(void 0, process.cwd()).value;
+    const engine = registry.get(provider);
+    if (!engine) {
+      throw new Error(`Provider "${provider}" not found for splitter shadow mode`);
+    }
+    let timeoutHandle;
+    const result = await Promise.race([
+      engine.run({
+        prompt: this.createSplitterShadowPrompt(input.prompt, input.numAgents),
+        workingDir: process.cwd(),
+        model: input.model,
+        profile: "default",
+        // Shadow splitting only parses stdout. This calls engine.run directly,
+        // so it does not inherit runProviderNative's read-only derivation.
+        executionIntent: "analysis",
+        readOnlyWorkingDir: true
+      }),
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`Splitter shadow timed out after ${SPLITTER_SHADOW_TIMEOUT_MS}ms`));
+        }, SPLITTER_SHADOW_TIMEOUT_MS);
+      })
+    ]).finally(() => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || "Splitter shadow provider call failed");
+    }
+    return result.stdout || "";
+  };
+  async runLlmSplitterShadow(prompt, numAgents, heuristicResult, splitOptions) {
+    if (!this.shouldRunLlmShadow(splitOptions)) {
+      return;
+    }
+    let parsedShadow = null;
+    let model = "auto";
+    let errorMessage;
+    try {
+      model = resolveSplitterModel(void 0, process.cwd()).value;
+      const stripped = stripPromptInjections(prompt);
+      const providerPrompt = stripped.length > 0 ? stripped : prompt;
+      const raw = await this.splitterShadowRunner({
+        prompt: providerPrompt,
+        numAgents,
+        model
+      });
+      parsedShadow = this.parseSplitterShadowResult(raw);
+      if (!parsedShadow) {
+        errorMessage = "Malformed provider JSON (strict pure-object parse failed)";
+      }
+    } catch (error) {
+      errorMessage = error instanceof Error ? error.message : String(error);
+    }
+    const heuristicSubTasks = this.getAllSubTasks(heuristicResult).map((task) => ({
+      id: task.id,
+      description: task.description,
+      files: task.files,
+      boundary: task.context,
+      dependencies: task.dependencies
+    }));
+    const shadowSubTasks = parsedShadow?.subtasks.map((task, index) => ({
+      id: typeof task.id === "number" ? task.id : index + 1,
+      description: task.description,
+      files: task.targetFiles ?? [],
+      boundary: task.boundary,
+      dependencies: task.dependencies ?? []
+    })) ?? [];
+    emitCustomWarning(
+      errorMessage ? "WARN" /* WARN */ : "INFO" /* INFO */,
+      "validation" /* VALIDATION */,
+      errorMessage ? "Task splitter LLM shadow split failed" : "Task splitter LLM shadow split comparison recorded",
+      {
+        subsystem: "orchestrator",
+        executionPhase: "setup"
+      },
+      {
+        metadata: {
+          model,
+          strategy: heuristicResult.strategy,
+          heuristicSubTaskCount: heuristicSubTasks.length,
+          llmSubTaskCount: shadowSubTasks.length,
+          heuristicSubTasks,
+          llmSubTasks: shadowSubTasks,
+          error: errorMessage
+        },
+        // Keep console quiet by default; telemetry capture remains structured.
+        skipConsole: true
+      }
+    );
+  }
+  /**
+   * Generate routing decisions for sub-tasks using RoutingPlanner
+   *
+   * @param subTasks - Array of sub-tasks to generate routing for
+   * @param domainAnalysis - Domain analysis result for context
+   * @returns Array of routing decisions for each sub-task
+   */
+  async generateRoutingDecisions(subTasks, domainAnalysis, routingOptions = {}) {
+    const { RoutingPlanner } = await import("./routing-planner-F5WQEUOM.js");
+    const { routingTelemetry } = await import("./routing-events-DHPUZDDF.js");
+    const planner = new RoutingPlanner();
+    const routingDecisions = [];
+    await routingTelemetry.emitEvent({
+      type: "task_split_with_routing",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      subTaskCount: subTasks.length,
+      strategy: "file-based",
+      // This will be updated by the caller
+      routingDecisionsCount: 0,
+      // Will be updated after generation
+      hasRoutingDecisions: true,
+      backlogSize: 0,
+      scaffoldingAttached: false,
+      domainTag: "general",
+      complexityTag: "high"
+    });
+    for (const subTask of subTasks) {
+      const generationStart = Date.now();
+      try {
+        const subTaskAnalysis = {
+          ...domainAnalysis,
+          domain: this.inferSubTaskDomain(subTask),
+          confidence: Math.max(0.5, domainAnalysis.confidence - 0.1)
+          // Slightly lower confidence for sub-tasks
+        };
+        const decision = planner.plan(subTaskAnalysis, {
+          subTaskId: `subtask-${subTask.id}`,
+          manualProvider: routingOptions.forceProvider,
+          allowExperimental: routingOptions.allowExperimental
+        });
+        routingDecisions.push(decision);
+        const inferredDomain = this.inferSubTaskDomain(subTask);
+        await routingTelemetry.emitEvent({
+          type: "subtask_routing_generated",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          subTaskId: `subtask-${subTask.id}`,
+          subTaskDescription: subTask.description,
+          primaryProvider: decision.primary.provider,
+          providerConfidence: decision.primary.confidence,
+          domainTag: inferredDomain,
+          complexityTag: "medium",
+          generationDuration: Date.now() - generationStart
+        });
+      } catch (_error) {
+        const fallbackProvider = resolveDefaultProvider(void 0, process.cwd()).value;
+        const fallbackDecision = {
+          subTaskId: `subtask-${subTask.id}`,
+          primary: {
+            provider: fallbackProvider,
+            confidence: 0.5,
+            rationale: ["Fallback routing due to planning error"],
+            setup: "local"
+          },
+          alternates: [],
+          rationale: ["Error in routing planning, using fallback"]
+        };
+        routingDecisions.push(fallbackDecision);
+        const fallbackDomain = this.inferSubTaskDomain(subTask);
+        await routingTelemetry.emitEvent({
+          type: "subtask_routing_generated",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          subTaskId: `subtask-${subTask.id}`,
+          subTaskDescription: subTask.description,
+          primaryProvider: fallbackProvider,
+          providerConfidence: 0.5,
+          domainTag: fallbackDomain,
+          complexityTag: "medium",
+          generationDuration: Date.now() - generationStart
+        });
+      }
+    }
+    return routingDecisions;
+  }
+  /**
+   * Infer domain for a sub-task based on its content
+   *
+   * @param subTask - Sub-task to analyze
+   * @returns Inferred domain category
+   */
+  inferSubTaskDomain(subTask) {
+    const description = subTask.description.toLowerCase();
+    const files = subTask.files.join(" ").toLowerCase();
+    const content = `${description} ${files}`;
+    if (content.includes("test") || content.includes("spec")) {
+      return "testing";
+    }
+    if (content.includes("ui") || content.includes("component") || content.includes("react")) {
+      return "frontend";
+    }
+    if (content.includes("api") || content.includes("endpoint") || content.includes("server")) {
+      return "backend";
+    }
+    if (content.includes("doc") || content.includes("readme") || content.includes("guide")) {
+      return "docs";
+    }
+    if (content.includes("config") || content.includes("setup") || content.includes("deploy")) {
+      return "infra";
+    }
+    return "general";
+  }
+  /**
+   * Create a single task result (helper for fallback cases)
+   */
+  createSingleTask(prompt, reasoning) {
+    return {
+      subTasks: [
+        {
+          id: 1,
+          description: prompt,
+          files: [],
+          context: "",
+          dependencies: []
+        }
+      ],
+      pendingSubTasks: [],
+      strategy: "single",
+      reasoning
+    };
+  }
+  async safeAnalyzeDomain(prompt) {
+    try {
+      return await this.domainAnalyzer.analyze(prompt);
+    } catch {
+      return this.createDefaultDomainAnalysis();
+    }
+  }
+  safeAnalyzeTaskCharacteristics(prompt, domainAnalysis) {
+    try {
+      return this.taskCharacteristicsAnalyzer.analyze(prompt, domainAnalysis);
+    } catch {
+      return this.createDefaultTaskAnalysis();
+    }
+  }
+  attachMetadataToSubTasks(subTasks, prompt, heuristics, domainAnalysis, taskAnalysis, strategy) {
+    if (subTasks.length === 0) {
+      return subTasks;
+    }
+    const promptHash = this.computePromptHash(prompt);
+    const batchId = `plan-${promptHash.slice(0, 8)}-${subTasks.length}`;
+    const heuristicsList = Array.from(heuristics).sort();
+    return subTasks.map((subTask, index) => ({
+      ...subTask,
+      metadata: {
+        heuristics: heuristicsList,
+        domain: domainAnalysis.domain,
+        domainConfidence: domainAnalysis.confidence,
+        characteristics: taskAnalysis.characteristics,
+        recommendedApproach: taskAnalysis.recommendedApproach,
+        estimatedComplexity: taskAnalysis.estimatedComplexity,
+        timeEstimate: taskAnalysis.timeEstimate,
+        batching: {
+          batchId,
+          position: index,
+          total: subTasks.length
+        },
+        persistence: {
+          checkpointId: `${batchId}-subtask-${subTask.id}`,
+          promptHash
+        },
+        strategy
+      }
+    }));
+  }
+  createPlaceholderMetadata(heuristics, domainAnalysis, taskAnalysis, prompt, strategy, total, index) {
+    const promptHash = this.computePromptHash(prompt);
+    const batchId = `plan-${promptHash.slice(0, 8)}-${total || 1}`;
+    const heuristicsList = Array.from(heuristics).sort();
+    return {
+      heuristics: heuristicsList,
+      domain: domainAnalysis.domain,
+      domainConfidence: domainAnalysis.confidence,
+      characteristics: taskAnalysis.characteristics,
+      recommendedApproach: taskAnalysis.recommendedApproach,
+      estimatedComplexity: taskAnalysis.estimatedComplexity,
+      timeEstimate: taskAnalysis.timeEstimate,
+      batching: {
+        batchId,
+        position: index,
+        total: total || 1
+      },
+      persistence: {
+        checkpointId: `${batchId}-subtask-${index + 1}`,
+        promptHash
+      },
+      strategy
+    };
+  }
+  createDefaultDomainAnalysis() {
+    return {
+      domain: "general",
+      confidence: 0.5,
+      filesMentioned: [],
+      requestedFiles: [],
+      featureCount: 0,
+      compareIntent: false,
+      speedIntent: false,
+      complexity: "medium",
+      isCritical: false,
+      signals: {
+        domainScores: {},
+        heuristicsApplied: []
+      }
+    };
+  }
+  createDefaultTaskAnalysis() {
+    return {
+      characteristics: {
+        fileTypes: [],
+        programmingLanguages: [],
+        fileCount: 0,
+        hasMultipleFiles: false,
+        hasComplexDependencies: false,
+        requiresRefactoring: false,
+        requiresTesting: false,
+        isBugFix: false,
+        isFeatureAddition: false,
+        isRefactoring: false,
+        isDocumentation: false,
+        isTesting: false,
+        requiresDatabaseChanges: false,
+        requiresAPIIntegration: false,
+        requiresUIImplementation: false,
+        requiresConfiguration: false,
+        requiresOptimization: false,
+        requiresSecurityReview: false,
+        requiresCodeReview: false,
+        isCriticalPath: false,
+        affectsMultipleModules: false,
+        requiresCoordination: false
+      },
+      confidence: 0,
+      rationale: [],
+      recommendedApproach: "conservative",
+      estimatedComplexity: "medium",
+      timeEstimate: {
+        min: 0,
+        max: 0,
+        confidence: 0
+      }
+    };
+  }
+  computePromptHash(prompt) {
+    return createHash("sha256").update(prompt).digest("hex");
+  }
+  /**
+   * Apply sequential batching to a task split result
+   * Divides sub-tasks into batches for sequential execution
+   *
+   * @param result - Task split result with sub-tasks
+   * @param numAgents - Number of agents per batch
+   * @returns Modified result with first batch in subTasks, rest in pendingSubTasks
+   */
+  applySequentialBatching(result, numAgents) {
+    if (result.subTasks.length > numAgents) {
+      const batches = [];
+      for (let i = 0; i < result.subTasks.length; i += numAgents) {
+        batches.push(result.subTasks.slice(i, i + numAgents));
+      }
+      return {
+        ...result,
+        subTasks: batches[0] || [],
+        pendingSubTasks: batches.slice(1),
+        reasoning: `${result.reasoning} (sequential batching: ${batches.length} phases)`
+      };
+    }
+    return result;
+  }
+  /**
+   * Split task into sequential chunks when it's very large
+   * Used when task exceeds 2x the recommended threshold
+   *
+   * @param prompt - Task description
+   * @param maxAgents - Max agents per chunk
+   * @param estimatedTokens - Total estimated tokens
+   * @param thresholdTokens - Recommended threshold
+   * @param tokenAnalysis - Token analysis result to include in response
+   * @returns Task split result with sequential chunks
+   */
+  async splitSequentially(prompt, maxAgents, estimatedTokens, thresholdTokens, tokenAnalysis) {
+    const chunks = [];
+    const targetTokensPerChunk = thresholdTokens;
+    const sections = prompt.split(/\n\n+/);
+    let currentChunk = "";
+    let currentTokens = 0;
+    for (const section of sections) {
+      const sectionTokens = estimateTokensHeuristic(section);
+      if (currentTokens + sectionTokens > targetTokensPerChunk && currentChunk) {
+        chunks.push(currentChunk.trim());
+        currentChunk = section;
+        currentTokens = sectionTokens;
+      } else {
+        currentChunk += (currentChunk ? "\n\n" : "") + section;
+        currentTokens += sectionTokens;
+      }
+    }
+    if (currentChunk.trim()) {
+      chunks.push(currentChunk.trim());
+    }
+    if (chunks.length === 1) {
+      const targetCharsPerChunk = Math.ceil(
+        prompt.length / Math.ceil(estimatedTokens / thresholdTokens)
+      );
+      chunks.length = 0;
+      for (let i = 0; i < prompt.length; i += targetCharsPerChunk) {
+        chunks.push(prompt.slice(i, i + targetCharsPerChunk));
+      }
+    }
+    const { firstBatch, pendingBatches } = this.buildBatchedSubTasks(
+      chunks,
+      maxAgents,
+      (chunk, id) => ({
+        id,
+        description: chunk,
+        files: [],
+        context: "Sequential chunk of large task",
+        dependencies: id > 1 ? [id - 1] : []
+      })
+    );
+    const sanitized = this.sanitizeBatches(firstBatch, pendingBatches);
+    const result = {
+      subTasks: sanitized.subTasks,
+      pendingSubTasks: sanitized.pendingSubTasks,
+      strategy: "sequential",
+      reasoning: `Task split into ${chunks.length} sequential chunks to fit context window (estimated ${estimatedTokens} tokens)`,
+      tokenAnalysis
+    };
+    this.validateCompleteExecution(result);
+    return result;
+  }
+  /**
+   * Validate that a split result guarantees complete execution
+   * Ensures all subtasks are valid and have proper dependencies
+   *
+   * @param result - Task split result to validate
+   * @throws Error if validation fails
+   */
+  validateCompleteExecution(result) {
+    const totalSubTasks = result.subTasks.length + result.pendingSubTasks.reduce((sum, batch) => sum + batch.length, 0);
+    if (totalSubTasks === 0 && !_TaskSplitter.ALLOW_ZERO_SUBTASKS.has(result.strategy)) {
+      console.error("[Task Splitter] CRITICAL: Split resulted in zero subtasks");
+      debugLog("[DEBUG] Split result:", result);
+      throw new Error(
+        "CRITICAL: Split resulted in zero subtasks. This is a bug. All tasks must produce at least one subtask."
+      );
+    }
+    const allSubTasks = [...result.subTasks, ...result.pendingSubTasks.flat()];
+    const ids = /* @__PURE__ */ new Set();
+    for (const subtask of allSubTasks) {
+      if (ids.has(subtask.id)) {
+        console.error(`[Task Splitter] CRITICAL: Duplicate subtask ID detected: ${subtask.id}`);
+        debugLog("[DEBUG] All subtasks:", allSubTasks);
+        throw new Error(
+          `CRITICAL: Duplicate subtask ID detected: ${subtask.id}. This violates subtask uniqueness guarantee.`
+        );
+      }
+      ids.add(subtask.id);
+    }
+    for (const subtask of allSubTasks) {
+      for (const depId of subtask.dependencies) {
+        if (!ids.has(depId)) {
+          console.error(
+            `[Task Splitter] CRITICAL: Subtask ${subtask.id} depends on non-existent task ${depId}`
+          );
+          debugLog("[DEBUG] Subtask:", subtask);
+          debugLog("[DEBUG] Valid IDs:", Array.from(ids));
+          throw new Error(
+            `CRITICAL: Subtask ${subtask.id} depends on non-existent task ${depId}. This would cause execution deadlock or failure.`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Cleanup resources (e.g., token estimator caches)
+   */
+  cleanup() {
+    this.tokenEstimator.cleanup();
+  }
+};
+
+export {
+  isAnalysisSubTask,
+  TaskSplitter
+};
+//# sourceMappingURL=chunk-JQNJB2BB.js.map