@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-UJYDH2MW.js

@@ -0,0 +1,305 @@
+import {
+  assertWorktreeCleanForReuse
+} from "./chunk-75EMT7BF.js";
+import {
+  WORKTREE_RECORD_CLEANUP_REASON,
+  deriveWorktreeOwnershipMetadata,
+  loadManifest,
+  registerWorktreeRecord,
+  updateWorktreeRecordStatus
+} from "./chunk-6TRD7TEE.js";
+import {
+  registerActiveRun
+} from "./chunk-2NMNFUQA.js";
+import {
+  CURRENT_BRANCH_REV_PARSE_ARGS,
+  parseCurrentBranchRef
+} from "./chunk-XGU6PBO5.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+
+// src/automation/flywheel-worktree-tracker.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+async function ensureWorktreeCleanForReuse(worktreePath, options = {}) {
+  return assertWorktreeCleanForReuse(worktreePath, options);
+}
+var WORKTREE_TRACKER_LIFECYCLE = {
+  PENDING_REGISTERED: "wt_tracker:pending_registered",
+  CLEANED_PATH_ABSENT: "wt_tracker:cleaned_path_absent",
+  RETAINED_PREFIX: "wt_tracker:retained:",
+  CLEANUP_FAILED: "wt_tracker:cleanup_failed"
+};
+async function adoptRetainedIntegrationWorktree(options) {
+  await options.assertLeaseOwned();
+  const manifest = await loadManifest(options.workflowId);
+  const candidates = [];
+  for (const record2 of manifest.worktreeRecords ?? []) {
+    if (record2.owner !== "integration" || record2.status !== "retained") continue;
+    if (!path.isAbsolute(record2.worktreePath)) {
+      throw new Error(
+        `Refusing to reuse worktree with a relative recorded path: ${record2.worktreePath}`
+      );
+    }
+    try {
+      if (!(await fs.stat(record2.worktreePath)).isDirectory()) {
+        throw new Error(
+          `Refusing to reuse worktree that is not a directory: ${record2.worktreePath}`
+        );
+      }
+      candidates.push(record2);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  if (candidates.length === 0) return void 0;
+  if (candidates.length !== 1) {
+    throw new Error(
+      `Refusing to reuse ambiguous integration worktrees: ${candidates.map((record2) => record2.worktreePath).join(", ")}`
+    );
+  }
+  const record = candidates[0];
+  const worktreePath = record.worktreePath;
+  const [repoGit, worktreeGit, branch] = await Promise.all([
+    execGit(["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      cwd: options.repoRoot,
+      timeoutMs: 1e4
+    }),
+    execGit(["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      cwd: worktreePath,
+      timeoutMs: 1e4
+    }),
+    execGit(["symbolic-ref", "--quiet", "--short", "HEAD"], {
+      cwd: worktreePath,
+      timeoutMs: 1e4
+    })
+  ]);
+  if (repoGit.exitCode !== 0 || worktreeGit.exitCode !== 0 || branch.exitCode !== 0 || record.branch !== options.branch || branch.stdout.trim() !== options.branch || await fs.realpath(repoGit.stdout.trim()) !== await fs.realpath(worktreeGit.stdout.trim())) {
+    throw new Error(
+      `Refusing to reuse worktree ${worktreePath}: repository or integration branch does not match ${options.branch}`
+    );
+  }
+  await ensureWorktreeCleanForReuse(worktreePath);
+  await options.assertLeaseOwned();
+  if (!await registerActiveRun(worktreePath, { command: "resume", runId: options.workflowId })) {
+    throw new Error(
+      `Failed to write active-run sentinel for ${worktreePath}; refusing to reuse a worktree unprotected from cleanup sweeps`
+    );
+  }
+  await registerWorktreeRecord(options.workflowId, {
+    worktreePath,
+    branch: options.branch,
+    owner: "integration",
+    ownership: deriveWorktreeOwnershipMetadata(options.workflowId, "integration"),
+    retentionReason: WORKTREE_TRACKER_LIFECYCLE.PENDING_REGISTERED
+  });
+  return worktreePath;
+}
+function formatRetainedReason(humanReason) {
+  const trimmed = humanReason.trim();
+  const safe = trimmed.length > 0 ? trimmed : "unspecified";
+  return `${WORKTREE_TRACKER_LIFECYCLE.RETAINED_PREFIX}${safe}`;
+}
+async function isWorktreeDirectoryPresent(worktreePath) {
+  try {
+    const stat2 = await fs.stat(worktreePath);
+    return stat2.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function trackWorktreeCreation(workflowId, worktreePath, branch, owner) {
+  try {
+    await registerWorktreeRecord(workflowId, {
+      worktreePath,
+      branch,
+      owner,
+      ownership: deriveWorktreeOwnershipMetadata(workflowId, owner),
+      retentionReason: WORKTREE_TRACKER_LIFECYCLE.PENDING_REGISTERED
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[worktree-tracker] Failed to register worktree ${worktreePath}: ${msg}`);
+  }
+}
+async function trackWorktreeCleaned(workflowId, worktreePath) {
+  try {
+    const retentionReason = await isWorktreeDirectoryPresent(worktreePath) ? WORKTREE_RECORD_CLEANUP_REASON.PATH_STILL_PRESENT_AFTER_SUCCESSFUL_CLEANUP : WORKTREE_TRACKER_LIFECYCLE.CLEANED_PATH_ABSENT;
+    await updateWorktreeRecordStatus(workflowId, worktreePath, "cleaned", retentionReason);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[worktree-tracker] Failed to mark worktree cleaned ${worktreePath}: ${msg}`);
+  }
+}
+async function trackWorktreeRetained(workflowId, worktreePath, reason) {
+  try {
+    await updateWorktreeRecordStatus(
+      workflowId,
+      worktreePath,
+      "retained",
+      formatRetainedReason(reason)
+    );
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[worktree-tracker] Failed to mark worktree retained ${worktreePath}: ${msg}`);
+  }
+}
+async function trackWorktreeCleanupFailed(workflowId, worktreePath, detail) {
+  try {
+    const note = detail !== void 0 && detail.trim().length > 0 ? `${WORKTREE_TRACKER_LIFECYCLE.CLEANUP_FAILED}|${detail.trim()}` : WORKTREE_TRACKER_LIFECYCLE.CLEANUP_FAILED;
+    await updateWorktreeRecordStatus(workflowId, worktreePath, "cleanup_failed", note);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[worktree-tracker] Failed to mark cleanup_failed ${worktreePath}: ${msg}`);
+  }
+}
+async function finalizeAbruptExecutorWorktreeManifestState(options) {
+  let secondaryLogged = false;
+  const warnOnce = (context, err) => {
+    if (secondaryLogged) {
+      return;
+    }
+    secondaryLogged = true;
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(`[worktree-tracker] finalize abrupt manifest (${context}): ${msg}`);
+  };
+  try {
+    if (!options.workflowResolved.current && options.workflowPath) {
+      try {
+        await trackWorktreeCleanupFailed(options.workflowId, options.workflowPath);
+      } catch (error) {
+        warnOnce("workflow", error);
+      } finally {
+        options.workflowResolved.current = true;
+      }
+    }
+    if (!options.baselineResolved.current && options.baselinePath) {
+      try {
+        await trackWorktreeCleanupFailed(options.workflowId, options.baselinePath);
+      } catch (error) {
+        warnOnce("baseline", error);
+      } finally {
+        options.baselineResolved.current = true;
+      }
+    }
+  } catch (error) {
+    warnOnce("outer", error);
+  }
+}
+
+// src/automation/stage-failure-disposition.ts
+function resolveOnFailureDisposition(decision) {
+  if (decision.action === "retry" || decision.shouldRetry) return "retry";
+  if (decision.action === "warn-continue") return "warn-continue";
+  if (decision.action === "skip-continue") return "skip-continue";
+  return "abort";
+}
+function isSchedulerNonHaltingStageResult(result) {
+  if (result.validationPassed) return true;
+  return result.onFailureDisposition === "warn-continue" || result.onFailureDisposition === "skip-continue";
+}
+function isProviderInvocationFailure(result) {
+  if (result.success) return false;
+  return result.terminationReason !== "completed" && result.terminationReason !== "canceled_user";
+}
+function keepsFailedWork(scope, result, validationPassed) {
+  return scope.keepWorkOnProviderFailure === true && !validationPassed && isProviderInvocationFailure(result);
+}
+var JUDGE_PROVIDER_FAILURE_REASONS = /* @__PURE__ */ new Set([
+  "timeout",
+  "error",
+  "sandbox_unavailable",
+  "judge-error"
+]);
+function judgeProviderFailed(decision) {
+  return decision?.judgeFailures?.some((f) => JUDGE_PROVIDER_FAILURE_REASONS.has(f.reason)) === true;
+}
+function competitionKeepsFailedWork(scope, result) {
+  if (scope.keepWorkOnProviderFailure !== true || result.validationPassed) return false;
+  const judge = result.competitionJudgeResult;
+  const judgeThrew = judge?.aiJudgeAttempted === true && judge.aiJudgeInvoked !== true && !!judge.aiJudgeError;
+  const judgeFailed = judgeThrew || judge?.aiJudgeProviderFailed === true;
+  return result.candidates.some((c) => c.providerFailed === true) || judgeFailed;
+}
+function providerFailureKeptReason(stageId, detail) {
+  return `provider-failure-kept:${stageId}${detail ? `: ${detail}` : ""}`;
+}
+function isProviderFailureKeptRecord(record) {
+  const prefix = `${WORKTREE_TRACKER_LIFECYCLE.RETAINED_PREFIX}provider-failure-kept:`;
+  return record.retentionReason?.startsWith(prefix) === true;
+}
+function stageKeepsFailedWork(result) {
+  if (result.keepFailedWork === true) return true;
+  const subStages = result.subStageResults;
+  return subStages?.some((entry) => entry.result?.keepFailedWork === true) === true;
+}
+var KEPT_WORK_RECOVERY = {
+  recoverable: false,
+  note: "A provider failure stopped the build; the work was kept and not retried, rolled back or replanned."
+};
+async function readBranch(worktreePath) {
+  try {
+    const head = await execGit([...CURRENT_BRANCH_REV_PARSE_ARGS], {
+      cwd: worktreePath,
+      timeoutMs: 1e4
+    });
+    const branch = head.exitCode === 0 ? parseCurrentBranchRef(head.stdout) : "";
+    return branch && branch !== "HEAD" ? branch : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function describeKeptSubStageWork(result, ctx) {
+  const worktreePath = result.subStageWorktreePath ?? ctx.worktreePath;
+  if (ctx.workflowId && result.subStageWorktreePath) {
+    await trackWorktreeRetained(
+      ctx.workflowId,
+      worktreePath,
+      providerFailureKeptReason(result.stageId)
+    );
+  }
+  const branch = await readBranch(worktreePath);
+  const where = branch ? `${worktreePath} (branch ${branch})` : worktreePath;
+  const cleanup = ctx.workflowId ? `; remove it with \`build run flywheel cleanup ${ctx.workflowId} --execute\` when done` : "";
+  const summary = (result.summary ?? "Provider failed").replace(/\.+$/u, "");
+  return {
+    ...result,
+    keepFailedWork: true,
+    ...result.subStageWorktreePath ? { subStageWorktreeRetained: true } : {},
+    summary: `${summary}. Work kept in ${where}${cleanup}.`
+  };
+}
+function providerFailureStopMessage(scope, provider, result, detail) {
+  if (scope.keepWorkOnProviderFailure !== true || !isProviderInvocationFailure(result)) {
+    return void 0;
+  }
+  return `Provider ${provider} failed: ${detail?.trim() || "no error output"}`;
+}
+function markProviderFailureStop(result, message) {
+  return { ...result, keepFailedWork: true, summary: `${message}. ${result.summary ?? ""}`.trim() };
+}
+
+export {
+  ensureWorktreeCleanForReuse,
+  adoptRetainedIntegrationWorktree,
+  trackWorktreeCreation,
+  trackWorktreeCleaned,
+  trackWorktreeRetained,
+  trackWorktreeCleanupFailed,
+  finalizeAbruptExecutorWorktreeManifestState,
+  resolveOnFailureDisposition,
+  isSchedulerNonHaltingStageResult,
+  isProviderInvocationFailure,
+  keepsFailedWork,
+  judgeProviderFailed,
+  competitionKeepsFailedWork,
+  providerFailureKeptReason,
+  isProviderFailureKeptRecord,
+  stageKeepsFailedWork,
+  KEPT_WORK_RECOVERY,
+  describeKeptSubStageWork,
+  providerFailureStopMessage,
+  markProviderFailureStop
+};
+//# sourceMappingURL=chunk-UJYDH2MW.js.map

package/dist/chunk-UKMPASIC.js

@@ -0,0 +1,399 @@
+import {
+  getProjectSourceExtensions,
+  isProjectSourcePath,
+  isProjectTestPath
+} from "./chunk-RPIMAMV7.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_VERBS = [
+  "implement",
+  "fix",
+  "refactor",
+  "build",
+  "support",
+  "optimi[zs]e",
+  "integrate",
+  "migrate"
+];
+function inflectedWordPattern(words, flags) {
+  const forms = words.flatMap(
+    (word) => word.endsWith("e") ? [word, `${word.slice(0, -1)}ing`] : [word]
+  );
+  return new RegExp(`\\b(?:${forms.join("|")})(?:e?s|e?d|ing)?\\b`, flags);
+}
+var EXECUTABLE_INTENT_PATTERNS = [
+  inflectedWordPattern(EXECUTABLE_INTENT_VERBS, "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));
+}
+var OWN_COMMAND_MENTION = /(?<![\w.-])build(?=(?:\s+[A-Za-z0-9][\w.-]*){1,3}\s+--?[A-Za-z])/g;
+function withoutOwnToolName(prompt) {
+  return prompt.replace(/\.build-project\b/gi, ".project").replace(/~\/\.build\b/g, "~/.home").replace(/(?<![\w.-])build\/(?=work\b|[\w.-]+\/)/g, "ref/").replace(/`build(?=\s)/g, "`cli").replace(OWN_COMMAND_MENTION, "cli");
+}
+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(?:e|es|ed|ing|ions?)|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(rawPrompt) {
+  const prompt = withoutOwnToolName(rawPrompt);
+  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(rawPrompt) {
+  const prompt = withoutOwnToolName(rawPrompt);
+  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,
+  DOCS_ONLY_PATTERNS,
+  EXECUTABLE_INTENT_VERBS,
+  inflectedWordPattern,
+  detectTaskType,
+  detectTaskTypeWithConfidence,
+  getTaskTypeDisplayName,
+  STRICT_TECHNICAL_TASK_TYPES,
+  isSpecialTaskType,
+  detectJudgeTaskKind
+};
+//# sourceMappingURL=chunk-UKMPASIC.js.map