@poetic-ai/poetic 1.42.0

package/dist/chunk-F5JO7HAS.js

@@ -0,0 +1,94 @@
+// src/cli/utils/formatting.ts
+function normalizeFileContent(content) {
+  return content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").trim();
+}
+function parseDurationMs(duration) {
+  const match = duration.match(/^(\d+)([smhd])$/);
+  if (!match || !match[1] || !match[2]) {
+    throw new Error(
+      `Invalid duration format: ${duration}. Use format like "1h", "30m", "2d", "60s"`
+    );
+  }
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    case "d":
+      return value * 24 * 60 * 60 * 1e3;
+    default:
+      throw new Error(`Unknown duration unit: ${unit}`);
+  }
+}
+function formatDurationMs(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+}
+function compactId(id) {
+  if (id.length <= 12) return id;
+  return id.includes("-") ? id.split("-")[0] || id.slice(0, 8) : id.slice(0, 8);
+}
+var GENERIC_MARKDOWN_TITLE_STUBS = /* @__PURE__ */ new Set(["goal", "intent", "prompt", "task"]);
+function normalizePromptTitleLine(line) {
+  const stripped = line.trim().replace(/^#+\s*/, "").trim();
+  return stripped.length > 0 ? stripped : void 0;
+}
+function extractTitleFromPrompt(prompt) {
+  if (!prompt) return void 0;
+  let genericFallback;
+  for (const line of prompt.split(/\r?\n/)) {
+    const title = normalizePromptTitleLine(line);
+    if (!title) continue;
+    if (GENERIC_MARKDOWN_TITLE_STUBS.has(title.toLowerCase())) {
+      genericFallback ??= title;
+      continue;
+    }
+    return title;
+  }
+  return genericFallback;
+}
+function formatTaskLabel(params) {
+  const { title, id, idStyle = "short" } = params;
+  const displayTitle = title?.trim();
+  if (!displayTitle) {
+    return idStyle === "full" ? id : compactId(id);
+  }
+  if (idStyle === "hidden") return displayTitle;
+  const displayId = idStyle === "full" ? id : compactId(id);
+  return `${displayTitle} (${displayId})`;
+}
+function formatExecutionModeLabel(mode) {
+  switch (mode) {
+    case "autoloop":
+      return "Autoloop";
+    case "repair_loop":
+      return "Repair Loop";
+    case "single_pass":
+      return "Single-Pass";
+  }
+}
+
+export {
+  normalizeFileContent,
+  parseDurationMs,
+  formatDurationMs,
+  compactId,
+  extractTitleFromPrompt,
+  formatTaskLabel,
+  formatExecutionModeLabel
+};
+//# sourceMappingURL=chunk-F5JO7HAS.js.map

package/dist/chunk-F7ER6ANO.js

@@ -0,0 +1,174 @@
+import {
+  collectDeclaredStageTargets
+} from "./chunk-IFCBYECK.js";
+
+// src/automation/flywheel-safety.ts
+import * as os from "os";
+function detectStageCapabilities(stage) {
+  if (stage.capabilities?.modifiesFiles !== void 0) {
+    return {
+      modifiesFiles: stage.capabilities.modifiesFiles,
+      readsFiles: stage.capabilities.readsFiles ?? true,
+      producesText: stage.capabilities.producesText ?? !stage.capabilities.modifiesFiles,
+      executionIntent: stage.capabilities.executionIntent
+    };
+  }
+  const modifiesFiles = stage.outputs !== void 0 && Object.values(stage.outputs).some((type) => type === "diff" || type === "files");
+  return {
+    modifiesFiles,
+    readsFiles: true,
+    // Safe assumption: all stages may read files
+    producesText: !modifiesFiles,
+    executionIntent: modifiesFiles ? "edit" : void 0
+  };
+}
+function hasExplicitCapabilities(stage) {
+  return stage.capabilities?.modifiesFiles !== void 0;
+}
+function groupStagesByDependencyDepth(stages) {
+  const stageMap = new Map(stages.map((s) => [s.id, s]));
+  const depths = /* @__PURE__ */ new Map();
+  function calculateDepth(stageId, visited = /* @__PURE__ */ new Set()) {
+    const cachedDepth = depths.get(stageId);
+    if (cachedDepth !== void 0) {
+      return cachedDepth;
+    }
+    if (visited.has(stageId)) {
+      throw new Error(`Circular dependency detected while grouping stages: ${stageId}`);
+    }
+    visited.add(stageId);
+    const stage = stageMap.get(stageId);
+    if (!stage || !stage.deps || stage.deps.length === 0) {
+      depths.set(stageId, 0);
+      visited.delete(stageId);
+      return 0;
+    }
+    const maxDepDep = Math.max(...stage.deps.map((dep) => calculateDepth(dep, visited)));
+    const depth = maxDepDep + 1;
+    depths.set(stageId, depth);
+    visited.delete(stageId);
+    return depth;
+  }
+  for (const stage of stages) {
+    calculateDepth(stage.id);
+  }
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const stage of stages) {
+    const depth = depths.get(stage.id) ?? 0;
+    if (!byDepth.has(depth)) {
+      byDepth.set(depth, []);
+    }
+    const stagesAtDepth = byDepth.get(depth);
+    if (stagesAtDepth) {
+      stagesAtDepth.push(stage);
+    }
+  }
+  return byDepth;
+}
+function validateParallelSafety(stages) {
+  const stagesByDepth = groupStagesByDependencyDepth(stages);
+  const warnings = [];
+  for (const stage of stages) {
+    if (!hasExplicitCapabilities(stage)) {
+      const inferred = detectStageCapabilities(stage);
+      if (inferred.modifiesFiles) {
+        warnings.push(
+          `Stage '${stage.id}' inferred as file-modifying but lacks explicit capabilities. Add: capabilities: { modifiesFiles: true }`
+        );
+      }
+    }
+  }
+  for (const [depth, stagesAtDepth] of stagesByDepth.entries()) {
+    const writeStages = stagesAtDepth.filter((s) => detectStageCapabilities(s).modifiesFiles);
+    if (writeStages.length > 1) {
+      warnings.push(
+        `Multiple file-modifying stages at dependency depth ${depth}: [${writeStages.map((s) => s.id).join(", ")}]. Executor will use footprint-based grouping as a best-effort scheduling hint and rely on worktree isolation for safety.`
+      );
+    }
+  }
+  return { valid: true, warnings: warnings.length > 0 ? warnings : void 0 };
+}
+function buildFlywheelConfig(workflow) {
+  const fileModifyingStages = workflow.stages.filter(
+    (s) => detectStageCapabilities(s).modifiesFiles
+  );
+  const hasFileModifyingStages = fileModifyingStages.length > 0;
+  const coreCount = Math.max(1, os.cpus().length);
+  const defaultMax = Math.min(5, coreCount * 2);
+  return {
+    maxConcurrent: defaultMax,
+    concurrencyReason: hasFileModifyingStages ? `Parallel execution enabled with isolation: ${fileModifyingStages.length} file-modifying stage(s) present (executor will enforce disjoint footprints)` : "Parallel execution allowed: all stages are read-only or text-only",
+    hasFileModifyingStages,
+    fileModifyingStageIds: fileModifyingStages.map((s) => s.id)
+  };
+}
+function getExecutionOrder(stages) {
+  const byDepth = groupStagesByDependencyDepth(stages);
+  const result = [];
+  const sortedDepths = Array.from(byDepth.keys()).sort((a, b) => a - b);
+  for (const depth of sortedDepths) {
+    const stagesAtDepth = byDepth.get(depth) ?? [];
+    const hasFileModifiers = stagesAtDepth.some((s) => detectStageCapabilities(s).modifiesFiles);
+    result.push({
+      stages: stagesAtDepth,
+      // Conservative helper only: text-only groups are trivially parallelizable.
+      // File-modifying groups require footprint partitioning in the executor.
+      canParallelize: !hasFileModifiers && stagesAtDepth.length > 1
+    });
+  }
+  return result;
+}
+function extractStageFootprint(stage) {
+  return { declaredPaths: collectDeclaredStageTargets(stage) };
+}
+function areFootprintsDisjoint(a, b) {
+  if (a.declaredPaths.length === 0 || b.declaredPaths.length === 0) {
+    return true;
+  }
+  for (const pathA of a.declaredPaths) {
+    for (const pathB of b.declaredPaths) {
+      if (pathA === pathB) {
+        return false;
+      }
+      if (pathA.startsWith(`${pathB}/`) || pathB.startsWith(`${pathA}/`)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function partitionByDisjointness(stages) {
+  if (stages.length === 0) return [];
+  if (stages.length === 1) return [stages];
+  const groups = [];
+  for (const stageCtx of stages) {
+    let placed = false;
+    for (const group of groups) {
+      const isDisjoint = group.every(
+        (member) => areFootprintsDisjoint(stageCtx.footprint, member.footprint)
+      );
+      if (isDisjoint) {
+        group.push(stageCtx);
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      groups.push([stageCtx]);
+    }
+  }
+  return groups;
+}
+
+export {
+  detectStageCapabilities,
+  hasExplicitCapabilities,
+  groupStagesByDependencyDepth,
+  validateParallelSafety,
+  buildFlywheelConfig,
+  getExecutionOrder,
+  extractStageFootprint,
+  areFootprintsDisjoint,
+  partitionByDisjointness
+};
+//# sourceMappingURL=chunk-F7ER6ANO.js.map

package/dist/chunk-FATUVIIN.js

@@ -0,0 +1,374 @@
+import {
+  getProjectSourceExtensions,
+  isProjectSourcePath,
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.js";
+
+// src/core/judge/task-type-detector.ts
+var TASK_TYPE_DISPLAY_NAMES = {
+  bug_fix: "Bug Fix",
+  feature: "Feature",
+  refactor: "Refactor",
+  security: "Security",
+  performance: "Performance",
+  documentation: "Documentation",
+  test: "Test",
+  analysis: "Analysis",
+  review: "Review",
+  migration: "Migration",
+  maintenance: "Maintenance",
+  general: "General"
+};
+var DOCS_ONLY_PATTERNS = [
+  /\bdocumentation[- ]only\b/i,
+  /\bdocs?[- ]only\b/i,
+  /\bcomments?\s+only\b/i,
+  /\bno\s+(?:logic|code|runtime|behavior)\s+changes?\b/i
+];
+var EXECUTABLE_INTENT_PATTERNS = [
+  /\b(implement|fix|refactor|build|support|optimi[zs]e|integrat|migrat)\b/i,
+  /\b(add|create|update)\b.*\b(code|logic|runtime|behavior|function|class|module|component|api|endpoint)\b/i
+];
+var SOURCE_EXTENSION_ALTERNATION = getProjectSourceExtensions().map((ext) => ext.replace(/^\./, "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).sort((a, b) => b.length - a.length || a.localeCompare(b)).join("|");
+var SOURCE_PATH_TOKEN_PATTERN = new RegExp(
+  `(?:^|[\\s\\u0060'"(])((?:[\\w.-]+/)+[\\w.-]+\\.(?:${SOURCE_EXTENSION_ALTERNATION}))(?![\\w-])`,
+  "i"
+);
+var CODE_OR_TEST_INTENT_PATTERNS = [
+  // Authoring/editing verbs paired with a source/test noun. `src` must be the
+  // standalone noun, not the `src/` component of a path ("Write docs for
+  // src/foo.py" is doc work; the path is handled by the source-path signal).
+  /\b(write|add|create|update|edit|modify|change|extend)\b[\s\S]{0,40}\b(test|tests|spec|specs|unit\s*test|coverage|function|method|class|module|component|handler|endpoint|route|source|src(?!\/))\b/i,
+  // Test-runner / assertion vocabulary, spanning JS and cross-language runners so
+  // non-Node targets are recognized as test work [B6].
+  /\b(unit.?test|integration.?test|e2e|vitest|jest|mocha|describe\(|it\(|expect\(|assert|pytest|unittest|go\s+test|cargo\s+test|rspec|junit|xctest)\b/i
+];
+function hasSourcePathSignal(prompt) {
+  return SOURCE_PATH_TOKEN_PATTERN.test(prompt);
+}
+function hasTestPathSignal(prompt) {
+  const pathTokens = (prompt.match(/[\w./+-]+/g) ?? []).map((token) => token.replace(/[.,]+$/, "")).filter((token) => token.includes("."));
+  return pathTokens.some((token) => isProjectTestPath(token) && isProjectSourcePath(token));
+}
+var AUTHORING_VERB_PATTERN = /\b(write|add|create|update|edit|modify|change|extend|implement|fix|refactor|build)\b(?!\s+(?:the\s+|more\s+|some\s+)?(?:documentation|docs?|readme|comments?|changelog|doc\s+comments?)\b)/i;
+function shouldSkipDocumentationPattern(prompt) {
+  if (CODE_OR_TEST_INTENT_PATTERNS.some((pattern) => pattern.test(prompt))) return true;
+  if (hasTestPathSignal(prompt)) return true;
+  return hasSourcePathSignal(prompt) && AUTHORING_VERB_PATTERN.test(prompt);
+}
+function hasDocsOnlyPromptSignal(prompt) {
+  return DOCS_ONLY_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+function hasExecutablePromptSignal(prompt) {
+  return EXECUTABLE_INTENT_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+var TASK_PATTERNS = [
+  // Analysis / investigation
+  {
+    type: "analysis",
+    patterns: [
+      /\b(analy[sz]e|investigat|diagnos|assess|audit)\b/i,
+      /\b(root\s*cause|post.?mortem|retro)\b/i,
+      /\b(evaluat|inspect|triage)\b/i
+    ],
+    weight: 1.3
+  },
+  // Review
+  {
+    type: "review",
+    patterns: [
+      /\b(review|feedback|critique)\b/i,
+      /\b(pr\s*review|code\s*review)\b/i,
+      /\bassess|evaluate\b/i
+    ],
+    negativePatterns: [/implement|fix|build/i],
+    weight: 1.1
+  },
+  // Security (check first - often overlaps with bug_fix)
+  {
+    type: "security",
+    patterns: [
+      /\b(security|vulnerab)/i,
+      /\b(auth(?:entication|orization)?)\b/i,
+      /\b(injection|xss|csrf|sql.?inject)/i,
+      /\b(sanitiz|escap[ei]|encrypt|decrypt)/i,
+      /\b(permission|access.?control|privilege)/i,
+      /\b(token|session|credential)/i
+    ],
+    weight: 1.5
+    // High confidence for security patterns
+  },
+  // Performance
+  {
+    type: "performance",
+    patterns: [
+      /\b(performance|optimi[zs])/i,
+      /\b(speed|latency|throughput)/i,
+      /\b(memory|heap|leak)/i,
+      /\b(cache|caching|memoiz)/i,
+      /\b(profil|benchmark)/i,
+      /\b(slow|fast|bottleneck)/i
+    ],
+    weight: 1.3
+  },
+  // Migration / upgrade
+  {
+    type: "migration",
+    patterns: [
+      /\b(migrat|upgrade|downgrade|port|convert|rewrite)\b/i,
+      /\b(move|shift)\b.*\b(monolith|service|repo|package)\b/i
+    ],
+    weight: 1.2
+  },
+  // Maintenance / chores
+  {
+    type: "maintenance",
+    patterns: [
+      /\b(maintenance|upkeep|house\s*keeping|chore)\b/i,
+      /\b(dep(s)?|dependency|dependencies)\b.*\b(update|bump)\b/i,
+      /\b(cleanup|tidy|sanitize)\b/i
+    ],
+    weight: 1
+  },
+  // Test-related
+  {
+    type: "test",
+    patterns: [
+      /\b(test|spec|coverage)/i,
+      /\b(mock|stub|spy|fake)/i,
+      /\b(assert|expect)/i,
+      /\b(describe|it\(|should)/i,
+      /\b(unit.?test|integration.?test|e2e)/i
+    ],
+    negativePatterns: [/fix.*test/i, /test.*fail/i, /broken.*test/i],
+    weight: 1.2
+  },
+  // Documentation
+  {
+    type: "documentation",
+    patterns: [
+      /\b(document|readme)/i,
+      /\b(comment|jsdoc|typedoc|tsdoc)/i,
+      /\b(api.?doc|docstring)/i,
+      /\b(explain|clarify|describe)/i,
+      /\b(guide|tutorial|example)/i
+    ],
+    negativePatterns: [/fix|bug|error/i, /\b(implement|build|feature|endpoint|handler|route)\b/i],
+    weight: 1.1
+  },
+  // Bug fix (common patterns)
+  {
+    type: "bug_fix",
+    patterns: [
+      /\b(fix|bug|error)/i,
+      /\b(crash|broken|regression)/i,
+      /\b(issue|problem|fail)/i,
+      /\b(exception|throw)/i,
+      /\b(undefined|null.?pointer|reference.?error)/i,
+      /\b(not.?working|doesn.?t.?work)/i,
+      /\b(incorrect|wrong|invalid)/i
+    ],
+    weight: 1
+  },
+  // Feature (new functionality)
+  {
+    type: "feature",
+    patterns: [
+      /\b(add)\b/i,
+      /\b(implement|build|introduce)\b/i,
+      /\b(create|new)\b.*\b(feature|endpoint|route|api|page|screen|component|command|workflow|integration|support|capability|enhancement)\b/i,
+      /\b(feature|functionality)/i,
+      /\b(support|enable|allow)/i,
+      /\b(capability|enhancement)/i
+    ],
+    negativePatterns: [/\b(document|documentation|readme|guide|template|claude\.md)\b/i],
+    weight: 1
+  },
+  // Refactor
+  {
+    type: "refactor",
+    patterns: [
+      /\b(refactor|clean|cleanup)/i,
+      /\b(reorgani[zs]|simplify|restructur)/i,
+      /\b(extract|rename|move)/i,
+      /\b(split|consolidat|merge)/i,
+      /\b(dedupe|dry|normalize)/i,
+      /\b(improve.?structure|improve.?design)/i
+    ],
+    weight: 1
+  }
+];
+function detectTaskType(prompt) {
+  const normalized = prompt.toLowerCase();
+  const docsMentioned = /\b(document|documentation|readme|docs?)\b/i.test(normalized);
+  const analysisMentioned = /\b(analy[sz]e|investigat|review|audit|assess)\b/i.test(normalized);
+  if (hasDocsOnlyPromptSignal(normalized) && !analysisMentioned && !shouldSkipDocumentationPattern(prompt)) {
+    return "documentation";
+  }
+  if (docsMentioned && !hasExecutablePromptSignal(normalized) && !shouldSkipDocumentationPattern(prompt)) {
+    return "documentation";
+  }
+  const skipDocumentationPattern = shouldSkipDocumentationPattern(prompt);
+  for (const patternDef of TASK_PATTERNS) {
+    if (patternDef.type === "documentation" && skipDocumentationPattern) {
+      continue;
+    }
+    if (patternDef.negativePatterns) {
+      const hasNegativeMatch = patternDef.negativePatterns.some(
+        (pattern) => pattern.test(normalized)
+      );
+      if (hasNegativeMatch) {
+        continue;
+      }
+    }
+    const hasMatch = patternDef.patterns.some((pattern) => pattern.test(normalized));
+    if (hasMatch) {
+      return patternDef.type;
+    }
+  }
+  return "general";
+}
+function detectTaskTypeWithConfidence(prompt) {
+  const normalized = prompt.toLowerCase();
+  const docsMentioned = /\b(document|documentation|readme|docs?)\b/i.test(normalized);
+  const analysisMentioned = /\b(analy[sz]e|investigat|review|audit|assess)\b/i.test(normalized);
+  if (hasDocsOnlyPromptSignal(normalized) && !analysisMentioned && !shouldSkipDocumentationPattern(prompt)) {
+    return {
+      type: "documentation",
+      confidence: 0.95,
+      matchedPatterns: ["docs_only"]
+    };
+  }
+  if (docsMentioned && !hasExecutablePromptSignal(normalized) && !shouldSkipDocumentationPattern(prompt)) {
+    return {
+      type: "documentation",
+      confidence: 0.75,
+      matchedPatterns: ["documentation"]
+    };
+  }
+  const skipDocumentationPattern = shouldSkipDocumentationPattern(prompt);
+  const results = [];
+  for (const patternDef of TASK_PATTERNS) {
+    const matches = [];
+    let score = 0;
+    if (patternDef.type === "documentation" && skipDocumentationPattern) {
+      continue;
+    }
+    if (patternDef.negativePatterns) {
+      const negativeMatches = patternDef.negativePatterns.filter(
+        (pattern) => pattern.test(normalized)
+      );
+      if (patternDef.type === "documentation" && negativeMatches.length > 0) {
+        continue;
+      }
+      if (negativeMatches.length > 0) {
+        score -= negativeMatches.length * 0.5;
+      }
+    }
+    for (const pattern of patternDef.patterns) {
+      const match = pattern.exec(normalized);
+      if (match) {
+        matches.push(match[1] || match[0]);
+        score += patternDef.weight || 1;
+      }
+    }
+    if (matches.length > 0 || score > 0) {
+      results.push({
+        type: patternDef.type,
+        score: Math.max(0, score),
+        // Don't allow negative scores
+        matches
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  const topResult = results[0];
+  if (!topResult || topResult.score === 0) {
+    return {
+      type: "general",
+      confidence: 0,
+      matchedPatterns: []
+    };
+  }
+  const totalScore = results.reduce((sum, r) => sum + r.score, 0);
+  const confidence = Math.min(1, topResult.score / Math.max(totalScore, 1));
+  return {
+    type: topResult.type,
+    confidence,
+    matchedPatterns: topResult.matches
+  };
+}
+function getTaskTypeDisplayName(type) {
+  return TASK_TYPE_DISPLAY_NAMES[type];
+}
+var STRICT_TECHNICAL_TASK_TYPES = /* @__PURE__ */ new Set([
+  "bug_fix",
+  "security",
+  "performance",
+  "test"
+]);
+function isSpecialTaskType(type) {
+  return type !== "general";
+}
+function detectJudgeTaskKind(prompt, variants) {
+  const detailedType = detectTaskType(prompt);
+  const isAnalysisPrompt = /\b(analy[sz]e|investigat|investigation|review|audit|assess|explain|research)\b/i.test(
+    prompt
+  ) || /\bout\s+of\s+scope\b/i.test(prompt) || /\bno\s+implementation\b/i.test(prompt) || /\bwithout\s+implementation\b/i.test(prompt);
+  const isDesignPrompt = /\b(design|architect|architecture|spec)\b/i.test(prompt);
+  const isPlanningPrompt = /\b(plan|outline|roadmap)\b/i.test(prompt);
+  const isPlanOnlyPrompt = /\b(output\s+only\b[\s\S]*\bplan\b|plan\s+only|no\s+code|no\s+patch(?:es)?|do\s+not\s+modify)\b/i.test(
+    prompt
+  );
+  const isNoEditExecution = variants?.every(
+    (v) => v.executionIntent === "analysis" || v.emptyChanges && v.success
+  );
+  const isAnalysisExecution = Boolean(isNoEditExecution && isAnalysisPrompt);
+  if (isPlanOnlyPrompt && isNoEditExecution) {
+    return "planning";
+  }
+  if (isDesignPrompt && isNoEditExecution) {
+    return "design";
+  }
+  switch (detailedType) {
+    case "bug_fix":
+      return "bugfix";
+    case "refactor":
+      return "refactor";
+    case "analysis":
+    case "review":
+      if (isDesignPrompt) {
+        return "design";
+      }
+      return "analysis";
+    case "documentation":
+      if (isAnalysisExecution || !variants || variants.length === 0) {
+        return "design";
+      }
+      return "implementation";
+    case "feature":
+      if (isAnalysisExecution) {
+        return "analysis";
+      }
+      return "implementation";
+    default:
+      if (isAnalysisExecution) {
+        return "analysis";
+      }
+      if (isPlanningPrompt && isNoEditExecution) {
+        return "planning";
+      }
+      return "implementation";
+  }
+}
+
+export {
+  TASK_TYPE_DISPLAY_NAMES,
+  detectTaskType,
+  detectTaskTypeWithConfidence,
+  getTaskTypeDisplayName,
+  STRICT_TECHNICAL_TASK_TYPES,
+  isSpecialTaskType,
+  detectJudgeTaskKind
+};
+//# sourceMappingURL=chunk-FATUVIIN.js.map