@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-HQXYYUNY.js

@@ -0,0 +1,1231 @@
+import {
+  estimateRuntime
+} from "./chunk-LDCF2MKN.js";
+import {
+  classifyFailure,
+  shouldFailover
+} from "./chunk-NWRUSEXG.js";
+import {
+  evaluateComplexity
+} from "./chunk-NEQUQHOX.js";
+import {
+  registry
+} from "./chunk-GOAQ2I7Y.js";
+import {
+  isNodeLikeProject
+} from "./chunk-MFADRRTR.js";
+import {
+  runProviderNative
+} from "./chunk-YQAAKTVH.js";
+import {
+  getProviderHealth
+} from "./chunk-UHRBTZYY.js";
+import {
+  resolveConfig
+} from "./chunk-IZZK3H6I.js";
+import {
+  normalizeEngineId
+} from "./chunk-SURZ2WFE.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  detectProjectCapabilities
+} from "./chunk-GNH3QGTL.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+
+// src/orchestrator/swarm-planner.ts
+import { randomUUID } from "crypto";
+import { promises as fs } from "fs";
+import * as path from "path";
+import chalk from "chalk";
+
+// src/core/config/decomposition-recovery.ts
+function providerSupportsApiTransportFallback(provider) {
+  try {
+    const config = ProviderRegistry.getProviderConfig(provider);
+    return config.channels.includes("api") && config.api?.base_url !== void 0;
+  } catch {
+    return false;
+  }
+}
+var PROVIDERS_WITH_API_TRANSPORT = (() => {
+  try {
+    return new Set(
+      ProviderRegistry.getAllProviderIds().filter((id) => providerSupportsApiTransportFallback(id))
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+})();
+var TRANSPORT_RETRY_CATEGORIES = /* @__PURE__ */ new Set([
+  "startup_timeout",
+  "transport_error"
+]);
+var SAME_PROVIDER_RETRY_CATEGORIES = /* @__PURE__ */ new Set([
+  "idle_terminated",
+  "output_malformed",
+  "startup_timeout",
+  "transport_error"
+]);
+function getDecompositionRecoveryPlan(candidate, failureCategory) {
+  const failoverEligible = shouldFailover(failureCategory);
+  const retryEligible = TRANSPORT_RETRY_CATEGORIES.has(failureCategory) || SAME_PROVIDER_RETRY_CATEGORIES.has(failureCategory);
+  if (!failoverEligible && !retryEligible) {
+    return "hard_fail";
+  }
+  if (process.env.POETIC_PLAN_DECOMPOSE_DISABLE_RECOVERY === "1") {
+    return "hard_fail";
+  }
+  if (providerSupportsApiTransportFallback(candidate.provider) && TRANSPORT_RETRY_CATEGORIES.has(failureCategory)) {
+    return "retry_same_transport";
+  }
+  if (SAME_PROVIDER_RETRY_CATEGORIES.has(failureCategory)) {
+    return "retry_same_provider";
+  }
+  return failoverEligible ? "failover_next_candidate" : "hard_fail";
+}
+
+// src/core/config/runtime-selection.ts
+async function checkProviderAuth(provider) {
+  const normalizedId = normalizeEngineId(provider);
+  try {
+    const providerModule = registry.get(normalizedId);
+    if (!providerModule?.auth?.isAuthenticated) {
+      return "no";
+    }
+    if (providerModule.auth.isAuthenticatedTriState) {
+      return await providerModule.auth.isAuthenticatedTriState({ mode: "passive" });
+    }
+    const isAuth = await providerModule.auth.isAuthenticated({ mode: "passive" });
+    return isAuth === true ? "yes" : "no";
+  } catch {
+    return "unknown";
+  }
+}
+function hasHighMidExecutionFailureRate(provider) {
+  const health = getProviderHealth(provider);
+  const midExecFailures = health.failuresByPhase.mid_execution ?? 0;
+  const total = health.totalFailures + health.totalSuccesses;
+  if (total < 3) return false;
+  return midExecFailures >= 3 && midExecFailures / total > 0.5;
+}
+async function filterAvailable(candidates, options = {}) {
+  const mockProvidersAllowed = process.env.POETIC_MOCK_PROVIDERS === "1" && process.env.POETIC_ALLOW_MOCK_PROVIDERS === "1";
+  const { skipAuthCheck = mockProvidersAllowed, skipHealthReorder = false } = options;
+  const available = [];
+  for (const candidate of candidates) {
+    if (skipAuthCheck) {
+      available.push(candidate);
+      continue;
+    }
+    let authState = "unknown";
+    try {
+      authState = await checkProviderAuth(candidate.provider);
+    } catch {
+      authState = "unknown";
+    }
+    if (authState !== "no") {
+      available.push(candidate);
+    }
+  }
+  if (skipHealthReorder || available.length <= 1) {
+    return available;
+  }
+  const scored = available.map((candidate) => ({
+    candidate,
+    health: getProviderHealth(candidate.provider)
+  }));
+  scored.sort((a, b) => {
+    if (a.health.degraded !== b.health.degraded) {
+      return a.health.degraded ? 1 : -1;
+    }
+    if (a.health.score !== b.health.score) {
+      return b.health.score - a.health.score;
+    }
+    return a.candidate.index - b.candidate.index;
+  });
+  return scored.map((entry) => entry.candidate);
+}
+function selectNext(candidates, failureContext) {
+  const {
+    failedProvider,
+    failedModel,
+    error,
+    failedIndex,
+    callSite,
+    policyOverrides,
+    gateHighMidExecutionFailureRate = false
+  } = failureContext;
+  const category = classifyFailure(error);
+  if (!shouldFailover(category, policyOverrides)) {
+    return { candidate: null, event: null };
+  }
+  const failedPos = candidates.findIndex((c) => c.index === failedIndex);
+  const startPos = failedPos === -1 ? 0 : failedPos + 1;
+  let next = null;
+  for (let i = startPos; i < candidates.length; i += 1) {
+    const candidate = candidates[i] ?? null;
+    if (!candidate) continue;
+    if (failedPos === -1 && candidate.provider.toLowerCase() === failedProvider.toLowerCase()) {
+      continue;
+    }
+    if (gateHighMidExecutionFailureRate && hasHighMidExecutionFailureRate(candidate.provider)) {
+      continue;
+    }
+    next = candidate;
+    break;
+  }
+  const now = Date.now();
+  const event = {
+    purpose: callSite,
+    attemptedProvider: failedProvider,
+    attemptedModel: failedModel,
+    failureType: category,
+    selectedProvider: next?.provider ?? "",
+    selectedModel: next?.model ?? "",
+    candidateIndex: next?.index ?? -1,
+    source: callSite,
+    timestamp: now,
+    decision: next ? "failed-over" : "skipped"
+  };
+  emitFailoverEvent(event);
+  return { candidate: next, event };
+}
+function emitFailoverEvent(event) {
+  try {
+    import("./warning-EGQGUUIO.js").then(({ emitTelemetryFallbackWarning }) => {
+      emitTelemetryFallbackWarning(`[failover] ${JSON.stringify(event)}`);
+    }).catch(() => {
+      console.warn(`[failover] ${JSON.stringify(event)}`);
+    });
+  } catch {
+    console.warn(`[failover] ${JSON.stringify(event)}`);
+  }
+}
+
+// src/orchestrator/swarm-planner.ts
+var DEFAULT_SCAN_DEPTH = 3;
+var MAX_DIRECTORY_ENTRIES = 400;
+var FRONTEND_HINTS = ["src/components", "src/ui", "app/", "pages/", "client/", "public/"];
+var BACKEND_HINTS = ["src/api", "src/server", "server/", "api/", "src/lib", "src/services"];
+var TEST_HINTS = ["tests", "__tests__", "test", "integration", "e2e"];
+var DOC_HINTS = ["docs", "guides", "handbook"];
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".poetic",
+  "node_modules",
+  "dist",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache"
+]);
+var DYNAMIC_AGENT_CAP = 8;
+var DEFAULT_DYNAMIC_AGENT_CAP = 6;
+var CLASSIC_WEBAPP_ROLES = ["backend", "frontend", "testing", "documentation"];
+var CLASSIC_WEBAPP_KEYWORDS = [
+  "build",
+  "implement",
+  "add",
+  "refactor",
+  "fix",
+  "feature",
+  "auth",
+  "api",
+  "frontend",
+  "backend",
+  "ui",
+  "service"
+];
+var ANALYSIS_KEYWORDS = [
+  "analyze",
+  "analysis",
+  "compare",
+  "research",
+  "benchmark",
+  "investigate",
+  "audit",
+  "evaluate",
+  "competitive",
+  "market",
+  "survey"
+];
+var IMPLEMENTATION_KEYWORDS = [
+  "build",
+  "implement",
+  "refactor",
+  "migrate",
+  "fix",
+  "ship",
+  "deliver",
+  "launch",
+  "upgrade",
+  "extend",
+  "optimize"
+];
+function normalizeRoleName(role) {
+  return role.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function humanizeRole(role) {
+  const normalized = role.replace(/[^a-z0-9]+/gi, " ").trim();
+  if (!normalized) return "Agent";
+  return normalized.split(/\s+/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function padRoleNames(baseRoles, targetCount, extras, fallbackPrefix) {
+  const roles = baseRoles.slice(0, targetCount);
+  const seen = new Set(roles.map((role) => normalizeRoleName(role) || role));
+  let extraIndex = 0;
+  while (roles.length < targetCount) {
+    const candidate = extras[extraIndex] ?? `${fallbackPrefix}-${roles.length + 1}`;
+    extraIndex += 1;
+    const normalized = normalizeRoleName(candidate) || candidate;
+    if (seen.has(normalized)) {
+      continue;
+    }
+    roles.push(candidate);
+    seen.add(normalized);
+  }
+  return roles;
+}
+function dedupeStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (!trimmed) continue;
+    seen.add(trimmed);
+  }
+  return Array.from(seen);
+}
+function isAnalysisTask(task) {
+  const lower = task.toLowerCase();
+  return ANALYSIS_KEYWORDS.some((keyword) => lower.includes(keyword));
+}
+function isImplementationTask(task) {
+  const lower = task.toLowerCase();
+  return IMPLEMENTATION_KEYWORDS.some((keyword) => lower.includes(keyword));
+}
+function isClassicWebAppProject(domain) {
+  const frameworks = domain.frameworks.map((framework) => framework.toLowerCase());
+  const hasWebFramework = frameworks.some(
+    (framework) => ["react", "next", "vue", "svelte", "angular", "express", "fastify", "nestjs"].some(
+      (hint) => framework.includes(hint)
+    )
+  ) || domain.hasFrontend || domain.hasBackend;
+  return hasWebFramework && domain.hasFrontend && domain.hasBackend;
+}
+function shouldUseClassicWebAppFastPath(task, domain, options) {
+  if (options.roles && options.roles.length > 0) {
+    return false;
+  }
+  const requestedAgents = options.agents;
+  if (requestedAgents !== void 0 && requestedAgents !== CLASSIC_WEBAPP_ROLES.length) {
+    return false;
+  }
+  if (!isClassicWebAppProject(domain)) {
+    return false;
+  }
+  const lower = task.toLowerCase();
+  const hasClassicKeyword = CLASSIC_WEBAPP_KEYWORDS.some((keyword) => lower.includes(keyword));
+  const isExplicitAnalysis = isAnalysisTask(task) && !hasClassicKeyword && !isImplementationTask(task);
+  return hasClassicKeyword || !isExplicitAnalysis;
+}
+function estimateDynamicAgentCount(task, domain, target) {
+  if (typeof target === "number" && Number.isFinite(target) && target > 0) {
+    return Math.min(Math.max(1, Math.round(target)), DYNAMIC_AGENT_CAP);
+  }
+  const lower = task.toLowerCase();
+  if (isAnalysisTask(task)) {
+    if (lower.includes("compare") || lower.includes("competitive") || lower.includes("market")) {
+      return 3;
+    }
+    return 2;
+  }
+  if (domain.metrics.totalFiles > 1e3 || domain.frameworks.length > 3) {
+    return 4;
+  }
+  if (isImplementationTask(task)) {
+    return 3;
+  }
+  return 2;
+}
+function summarizeProjectDomain(domain) {
+  const lines = [
+    `Project root: ${domain.rootPath}`,
+    `Tech stack: ${domain.techStack.join(", ") || "unknown"}`,
+    `Languages: ${domain.languages.join(", ") || "unknown"}`,
+    `Frameworks: ${domain.frameworks.join(", ") || "none detected"}`,
+    `Directories: frontend=${domain.directories.frontend.length}, backend=${domain.directories.backend.length}, tests=${domain.directories.tests.length}, docs=${domain.directories.docs.length}`,
+    `File metrics: total=${domain.metrics.totalFiles}, code=${domain.metrics.codeFiles}, tests=${domain.metrics.testFiles}, docs=${domain.metrics.docFiles}`
+  ];
+  if ((domain.metrics.truncatedDirectoryEntries ?? 0) > 0) {
+    lines.push(
+      `Survey bounds: ${domain.metrics.truncatedDirectoryEntries} directory entries omitted by scan cap`
+    );
+  }
+  if (domain.notes.length > 0) {
+    lines.push(`Notes: ${domain.notes.join(" | ")}`);
+  }
+  return lines.join("\n");
+}
+var SWARM_ROLE_BASE_RUNTIME_MS = 10 * 6e4;
+function estimateSubtaskRuntimeMinutes(objective) {
+  const complexity = evaluateComplexity(objective).complexityScore;
+  const complexityMultiplier = 0.5 + 2 * Math.max(0, Math.min(1, complexity));
+  const estimate = estimateRuntime({
+    baseExpectedRuntimeMs: SWARM_ROLE_BASE_RUNTIME_MS,
+    complexityMultiplier,
+    factors: ["swarm-role", `complexity=${complexity.toFixed(2)}`]
+  });
+  return Math.max(1, Math.round(estimate.expectedRuntimeMs / 6e4));
+}
+function createSubtask(role, summary, objective, acceptanceCriteria, suggestedArtifacts, dependencies = [], mandate) {
+  const normalizedDependencies = dedupeStrings(dependencies);
+  return {
+    id: `${normalizeRoleName(role) || "agent"}-${randomUUID()}`,
+    role,
+    summary,
+    description: objective,
+    mandate,
+    dependencies: normalizedDependencies,
+    acceptanceCriteria: dedupeStrings(acceptanceCriteria),
+    suggestedArtifacts: dedupeStrings(suggestedArtifacts),
+    expectedRuntimeMinutes: estimateSubtaskRuntimeMinutes(objective)
+  };
+}
+async function readJson(file) {
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    return parseJsonWithContext(raw, `Swarm planner JSON (${file})`);
+  } catch {
+    return null;
+  }
+}
+async function statSafe(target) {
+  try {
+    return await fs.stat(target);
+  } catch {
+    return null;
+  }
+}
+async function surveyDirectory(root, maxDepth) {
+  const survey = {
+    totalFiles: 0,
+    codeFiles: 0,
+    testFiles: 0,
+    docFiles: 0,
+    truncatedDirectoryEntries: 0,
+    frontend: /* @__PURE__ */ new Set(),
+    backend: /* @__PURE__ */ new Set(),
+    tests: /* @__PURE__ */ new Set(),
+    docs: /* @__PURE__ */ new Set(),
+    languages: /* @__PURE__ */ new Set()
+  };
+  async function walk(current, currentDepth) {
+    if (currentDepth > maxDepth) {
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs.readdir(current);
+    } catch {
+      return;
+    }
+    const surveyableEntries = entries.filter((entry) => !IGNORE_DIRS.has(entry));
+    if (surveyableEntries.length > MAX_DIRECTORY_ENTRIES) {
+      survey.truncatedDirectoryEntries += surveyableEntries.length - MAX_DIRECTORY_ENTRIES;
+    }
+    for (const entry of surveyableEntries.slice(0, MAX_DIRECTORY_ENTRIES)) {
+      const fullPath = path.join(current, entry);
+      const stats = await statSafe(fullPath);
+      if (!stats) continue;
+      if (stats.isDirectory()) {
+        await walk(fullPath, currentDepth + 1);
+        continue;
+      }
+      survey.totalFiles += 1;
+      const relativePath = path.relative(root, fullPath);
+      const lowerPath = relativePath.toLowerCase();
+      const ext = path.extname(entry).replace(/\./, "");
+      if (/(^|\/)tests?\//.test(lowerPath) || /\.test\./.test(lowerPath)) {
+        survey.testFiles += 1;
+        survey.tests.add(path.dirname(relativePath));
+      } else if (/(^|\/)docs?\//.test(lowerPath) || /\.mdx?$/.test(lowerPath)) {
+        survey.docFiles += 1;
+        survey.docs.add(path.dirname(relativePath));
+      } else {
+        survey.codeFiles += 1;
+      }
+      if (FRONTEND_HINTS.some((hint) => lowerPath.includes(hint))) {
+        survey.frontend.add(path.dirname(relativePath));
+      }
+      if (BACKEND_HINTS.some((hint) => lowerPath.includes(hint))) {
+        survey.backend.add(path.dirname(relativePath));
+      }
+      if (TEST_HINTS.some((hint) => lowerPath.includes(hint))) {
+        survey.tests.add(path.dirname(relativePath));
+      }
+      if (DOC_HINTS.some((hint) => lowerPath.includes(hint))) {
+        survey.docs.add(path.dirname(relativePath));
+      }
+      if (ext) {
+        survey.languages.add(ext.toLowerCase());
+      }
+    }
+  }
+  await walk(root, 0);
+  return survey;
+}
+function detectFrameworks(pkg, survey) {
+  const frameworks = /* @__PURE__ */ new Set();
+  const dependencies = /* @__PURE__ */ new Set();
+  if (pkg?.dependencies && typeof pkg.dependencies === "object") {
+    Object.keys(pkg.dependencies).forEach((dep) => {
+      dependencies.add(dep);
+    });
+  }
+  if (pkg?.devDependencies && typeof pkg.devDependencies === "object") {
+    Object.keys(pkg.devDependencies).forEach((dep) => {
+      dependencies.add(dep);
+    });
+  }
+  const addIf = (cond, name) => {
+    if (cond) frameworks.add(name);
+  };
+  addIf(dependencies.has("next"), "Next.js");
+  addIf(dependencies.has("react") || survey.frontend.size > 0, "React");
+  addIf(dependencies.has("vue"), "Vue");
+  addIf(dependencies.has("@angular/core"), "Angular");
+  addIf(dependencies.has("svelte") || dependencies.has("@sveltejs/kit"), "Svelte");
+  addIf(dependencies.has("express"), "Express");
+  addIf(dependencies.has("fastify"), "Fastify");
+  addIf(dependencies.has("@nestjs/core"), "NestJS");
+  addIf(dependencies.has("prisma"), "Prisma");
+  addIf(dependencies.has("vitest") || dependencies.has("jest"), "Automated Tests");
+  return Array.from(frameworks);
+}
+function inferDependencies(subtasks) {
+  const adjacency = {};
+  const inDegree = /* @__PURE__ */ new Map();
+  const issues = [];
+  const subtaskIds = new Set(subtasks.map((task) => task.id));
+  for (const subtask of subtasks) {
+    const validDeps = [];
+    for (const dep of subtask.dependencies) {
+      if (!subtaskIds.has(dep)) {
+        issues.push(`Dangling dependency reference: ${subtask.id} depends on missing task ${dep}.`);
+        continue;
+      }
+      validDeps.push(dep);
+    }
+    adjacency[subtask.id] = validDeps;
+    inDegree.set(subtask.id, validDeps.length);
+  }
+  const queue = subtasks.filter((task) => (inDegree.get(task.id) ?? 0) === 0);
+  const phases = [];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const phaseTasks = queue.splice(0);
+    phases.push({
+      id: `phase-${phases.length + 1}`,
+      description: `Parallel execution slot ${phases.length + 1}`,
+      subtasks: phaseTasks.map((t) => t.id)
+    });
+    for (const task of phaseTasks) {
+      visited.add(task.id);
+      for (const [candidateId, deps] of Object.entries(adjacency)) {
+        if (deps.includes(task.id)) {
+          const degree = (inDegree.get(candidateId) ?? 0) - 1;
+          inDegree.set(candidateId, degree);
+          if (degree === 0) {
+            const candidate = subtasks.find((item) => item.id === candidateId);
+            if (candidate) {
+              queue.push(candidate);
+            }
+          }
+        }
+      }
+    }
+  }
+  const hasCycles = visited.size !== subtasks.length;
+  if (hasCycles) {
+    issues.push("Dependency cycle detected; defaulting to sequential execution.");
+  }
+  const normalizedPhases = hasCycles ? subtasks.map((task, index) => ({
+    id: `phase-${index + 1}`,
+    description: `${humanizeRole(task.role)} fallback phase`,
+    subtasks: [task.id]
+  })) : phases;
+  return { adjacency, phases: normalizedPhases, hasCycles, issues };
+}
+function buildClassicWebAppPlan(task, domain) {
+  const normalizedTask = task.trim();
+  const subtasks = [];
+  const backendMandate = [
+    `You are the backend agent for the swarm task "${normalizedTask}".`,
+    "Mission: implement and stabilize the server-side work needed for the task.",
+    `Project context: ${summarizeProjectDomain(domain)}`,
+    "Focus on APIs, persistence, integration contracts, and any server scaffolding required to unblock the rest of the work.",
+    "Deliverables:",
+    "- API contracts or server behavior changes",
+    "- Error handling and logging improvements",
+    "- Core backend logic validated by tests or clear verification notes"
+  ].join("\n");
+  const backendTask = createSubtask(
+    "backend",
+    "Backend coordination",
+    `Implement and stabilize the server-side work needed for ${normalizedTask}. Focus on APIs, persistence, and integration contracts.`,
+    [
+      "API contracts documented",
+      "Error handling and logging present",
+      "Core backend logic covered by tests"
+    ],
+    domain.directories.backend.length > 0 ? domain.directories.backend.map((dir) => path.join(dir, "**/*")) : ["src/server/**/*", "src/api/**/*"],
+    [],
+    backendMandate
+  );
+  subtasks.push(backendTask);
+  const frontendDependencies = [backendTask.id];
+  const frontendMandate = [
+    `You are the frontend agent for the swarm task "${normalizedTask}".`,
+    "Mission: deliver the user-facing experience and align UI behavior with the backend contract.",
+    `Project context: ${summarizeProjectDomain(domain)}`,
+    "Focus on navigation, loading states, error handling, accessibility, and any view-layer changes required by the task.",
+    "Deliverables:",
+    "- UI changes or design adjustments",
+    "- Loading, empty, and error states handled cleanly",
+    "- Accessibility and interaction notes for review"
+  ].join("\n");
+  const frontendTask = createSubtask(
+    "frontend",
+    "Frontend coordination",
+    `Deliver the user-facing experience for ${normalizedTask}. Align UI behavior with backend contracts and ensure loading, empty, and error states are handled cleanly.`,
+    [
+      "UI flows cover happy and error paths",
+      "Accessibility considerations applied",
+      "Backend contract integration validated"
+    ],
+    domain.directories.frontend.length > 0 ? domain.directories.frontend.map((dir) => path.join(dir, "**/*")) : ["src/components/**/*", "src/ui/**/*"],
+    frontendDependencies,
+    frontendMandate
+  );
+  subtasks.push(frontendTask);
+  const testingMandate = [
+    `You are the testing agent for the swarm task "${normalizedTask}".`,
+    "Mission: extend or bootstrap automated verification for the web-app change.",
+    `Project context: ${summarizeProjectDomain(domain)}`,
+    "Focus on regression coverage, integration behavior, and any edge cases introduced by the task.",
+    "Deliverables:",
+    "- Test additions or validation notes",
+    "- Critical paths and regressions covered",
+    "- Negative scenarios documented clearly"
+  ].join("\n");
+  const testingTask = createSubtask(
+    "testing",
+    "Testing coverage",
+    `Extend or bootstrap automated verification for ${normalizedTask}. Cover core logic, integration paths, and the expected regressions for the web application flow.`,
+    [
+      "Regression suite extended with new cases",
+      "Critical paths validated with integration tests",
+      "Negative scenarios documented"
+    ],
+    domain.directories.tests.length > 0 ? domain.directories.tests.map((dir) => path.join(dir, "**/*")) : ["tests/**/*"],
+    [backendTask.id],
+    testingMandate
+  );
+  subtasks.push(testingTask);
+  const docsMandate = [
+    `You are the documentation agent for the swarm task "${normalizedTask}".`,
+    "Mission: update README files, guides, or onboarding materials so the change can be understood and reused.",
+    `Project context: ${summarizeProjectDomain(domain)}`,
+    "Focus on describing the user-visible change, implementation notes, and how to verify the result.",
+    "Deliverables:",
+    "- Documentation or changelog updates",
+    "- Usage examples refreshed",
+    "- Verification notes for maintainers"
+  ].join("\n");
+  const documentationTask = createSubtask(
+    "documentation",
+    "Documentation update",
+    `Update README files, guides, or onboarding materials to reflect ${normalizedTask}. Capture the implementation notes and any changes in how the feature should be used or verified.`,
+    ["README or docs updated", "Changelog entry created if necessary", "Usage examples refreshed"],
+    domain.directories.docs.length > 0 ? domain.directories.docs.map((dir) => path.join(dir, "**/*")) : ["docs/**/*", "README.md"],
+    [backendTask.id, frontendTask.id, testingTask.id],
+    docsMandate
+  );
+  subtasks.push(documentationTask);
+  const dependencyGraph = inferDependencies(subtasks);
+  const issues = [...dependencyGraph.issues];
+  if (!domain.hasBackend) {
+    issues.push("Backend stack not detected. Backend agent will bootstrap required scaffolding.");
+  }
+  if (!domain.hasFrontend) {
+    issues.push("Frontend stack not detected. Frontend agent will bootstrap UI foundation.");
+  }
+  return {
+    task: normalizedTask,
+    domain,
+    subtasks,
+    phases: dependencyGraph.phases,
+    issues,
+    planningMode: "classic-webapp",
+    planningReasoning: "Classic web-app fast path selected from project structure and task intent.",
+    agentCount: subtasks.length
+  };
+}
+function buildMandateVariants(task, domain, roleSpec) {
+  const roleLabel = humanizeRole(roleSpec.role);
+  return [
+    `You are the ${roleLabel} for the swarm task "${task}".`,
+    `Role label: ${roleSpec.role}`,
+    `Mission: ${roleSpec.objective}`,
+    `Project context: ${summarizeProjectDomain(domain)}`,
+    "Acceptance criteria:",
+    ...roleSpec.acceptanceCriteria.map((criterion) => `- ${criterion}`),
+    "Expected artifacts:",
+    ...roleSpec.suggestedArtifacts.map((artifact) => `- ${artifact}`),
+    roleSpec.dependsOn.length > 0 ? `Dependencies: wait for ${roleSpec.dependsOn.join(", ")} before finalizing your output.` : "Dependencies: none; proceed independently.",
+    "Rules:",
+    "- Stay within your specialization and do not duplicate other agents.",
+    "- Output concrete work, not a generic plan.",
+    "- If this is analysis work, produce evidence and comparison notes.",
+    "- If this is implementation work, cite the code paths, files, or interfaces you will touch."
+  ].join("\n");
+}
+function buildDynamicPlanFromSpecs(task, domain, specs, planningMode, reasoning) {
+  const subtasks = specs.map(
+    (spec) => createSubtask(
+      spec.role,
+      spec.summary,
+      spec.objective,
+      spec.acceptanceCriteria,
+      spec.suggestedArtifacts,
+      [],
+      buildMandateVariants(task, domain, spec)
+    )
+  );
+  const roleToId = /* @__PURE__ */ new Map();
+  subtasks.forEach((subtask, index) => {
+    roleToId.set(normalizeRoleName(specs[index]?.role ?? subtask.role), subtask.id);
+  });
+  subtasks.forEach((subtask, index) => {
+    const deps = specs[index]?.dependsOn ?? [];
+    const missingRoles = deps.filter(
+      (dep) => roleToId.has(normalizeRoleName(dep) || dep) === false
+    );
+    if (missingRoles.length > 0) {
+      throw new Error(
+        `Unknown dependency role(s) for "${subtask.role}": ${missingRoles.join(", ")}`
+      );
+    }
+    subtask.dependencies = dedupeStrings(
+      deps.map((dep) => roleToId.get(normalizeRoleName(dep) || dep)).filter((value) => typeof value === "string" && value.length > 0)
+    );
+  });
+  const dependencyGraph = inferDependencies(subtasks);
+  return {
+    task: task.trim(),
+    domain,
+    subtasks,
+    phases: dependencyGraph.phases,
+    issues: dependencyGraph.issues,
+    planningMode,
+    planningReasoning: reasoning,
+    agentCount: subtasks.length
+  };
+}
+function synthesizeAnalysisPlan(task, domain, requestedAgents, explicitRoles, planningMode = "fallback") {
+  const agentCount = explicitRoles && explicitRoles.length > 0 ? explicitRoles.length : estimateDynamicAgentCount(task, domain, requestedAgents);
+  const normalizedTask = task.trim();
+  const roleNames = explicitRoles && explicitRoles.length > 0 ? explicitRoles : agentCount === 1 ? ["researcher"] : agentCount === 2 ? ["researcher", "synthesizer"] : padRoleNames(
+    ["researcher", "analyst", "synthesizer"],
+    agentCount,
+    ["reviewer", "fact-checker", "source-curator"],
+    "research-role"
+  );
+  const specs = roleNames.slice(0, agentCount).map((role, index, roles) => {
+    const normalized = normalizeRoleName(role) || `agent-${index + 1}`;
+    const isFinal = index === roles.length - 1;
+    const isFirst = index === 0;
+    const objective = isFinal ? `Synthesize findings for ${normalizedTask}, reconcile differences, and produce the final comparison narrative.` : isFirst ? `Gather high-signal sources, baseline context, and the minimum facts needed to understand ${normalizedTask}.` : `Analyze and compare the key evidence for ${normalizedTask}, focusing on gaps, tradeoffs, and differentiated findings.`;
+    return {
+      role: normalized,
+      summary: humanizeRole(normalized),
+      objective,
+      acceptanceCriteria: isFinal ? [
+        "Findings are reconciled into a coherent conclusion",
+        "Key tradeoffs and uncertainties are called out",
+        "Output is ready to brief a decision-maker"
+      ] : isFirst ? [
+        "Sources are documented with enough detail to verify claims",
+        "Current state and context are captured before analysis",
+        "No unsupported assumptions are introduced"
+      ] : [
+        "Comparative evidence is organized by theme or criterion",
+        "Conflicting signals are identified explicitly",
+        "Analysis stays grounded in observable data"
+      ],
+      suggestedArtifacts: isFinal ? ["synthesis-notes.md", "comparison-summary.md"] : isFirst ? ["research-notes.md", "source-index.md"] : ["analysis-table.md", "evidence-log.md"],
+      dependsOn: isFirst ? [] : [roleNames[0] ?? "researcher"]
+    };
+  });
+  const reasoning = explicitRoles && explicitRoles.length > 0 ? `Explicit role override supplied; using ${specs.length} requested analysis role(s).` : `Heuristic dynamic decomposition selected ${specs.length} agent(s) for an analysis-oriented task.`;
+  return buildDynamicPlanFromSpecs(normalizedTask, domain, specs, planningMode, reasoning);
+}
+function synthesizeImplementationPlan(task, domain, requestedAgents, explicitRoles, planningMode = "fallback") {
+  const agentCount = explicitRoles && explicitRoles.length > 0 ? explicitRoles.length : estimateDynamicAgentCount(task, domain, requestedAgents);
+  const normalizedTask = task.trim();
+  const baseRoles = explicitRoles && explicitRoles.length > 0 ? explicitRoles : agentCount === 1 ? ["implementer"] : agentCount === 2 ? ["architect", "implementer"] : agentCount === 3 ? ["architect", "implementer", "verifier"] : padRoleNames(
+    ["architect", "implementer", "verifier", "synthesizer"],
+    agentCount,
+    ["integrator", "release-manager", "stabilizer"],
+    "implementation-role"
+  );
+  const specs = baseRoles.slice(0, agentCount).map((role, index, roles) => {
+    const normalized = normalizeRoleName(role) || `agent-${index + 1}`;
+    const isFinal = index === roles.length - 1;
+    const objective = isFinal ? `Tie the work together for ${normalizedTask}, resolve remaining edges, and produce the final integration notes.` : index === 0 ? `Design the implementation approach for ${normalizedTask} and identify the code paths that need to change.` : `Implement and validate the changes required for ${normalizedTask}, keeping the outcome aligned with the project context.`;
+    return {
+      role: normalized,
+      summary: humanizeRole(normalized),
+      objective,
+      acceptanceCriteria: isFinal ? [
+        "All critical paths are covered by implementation or validation",
+        "Remaining risks are documented clearly",
+        "Output is ready for handoff or merge"
+      ] : index === 0 ? [
+        "Implementation approach is scoped and grounded in the current codebase",
+        "Dependencies and affected files are identified",
+        "Risky assumptions are surfaced early"
+      ] : [
+        "Concrete changes are made in the relevant code paths",
+        "Validation or tests are updated alongside the implementation",
+        "Edge cases and regressions are considered"
+      ],
+      suggestedArtifacts: isFinal ? ["integration-notes.md", "handoff-summary.md"] : index === 0 ? ["implementation-plan.md", "affected-files.md"] : ["diff-notes.md", "verification-checklist.md"],
+      dependsOn: isFinal && roles.length > 1 ? roles.slice(0, -1).map((role2) => normalizeRoleName(role2)) : index === 0 ? [] : [normalizeRoleName(baseRoles[0] ?? "implementer")]
+    };
+  });
+  const reasoning = explicitRoles && explicitRoles.length > 0 ? `Explicit role override supplied; using ${specs.length} requested implementation role(s).` : `Heuristic dynamic decomposition selected ${specs.length} agent(s) for an implementation-oriented task.`;
+  return buildDynamicPlanFromSpecs(normalizedTask, domain, specs, planningMode, reasoning);
+}
+function parseRoleSpecs(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw;
+  const subtasksRaw = Array.isArray(record.subtasks) ? record.subtasks : [];
+  const subtasks = [];
+  for (const item of subtasksRaw) {
+    if (!item || typeof item !== "object") continue;
+    const subtask = item;
+    const role = typeof subtask.role === "string" ? subtask.role.trim() : "";
+    const summary = typeof subtask.summary === "string" ? subtask.summary.trim() : "";
+    const objective = typeof subtask.objective === "string" ? subtask.objective.trim() : typeof subtask.mandate === "string" ? subtask.mandate.trim() : typeof subtask.description === "string" ? subtask.description.trim() : "";
+    if (!role || !summary || !objective) continue;
+    subtasks.push({
+      role,
+      summary,
+      objective,
+      acceptanceCriteria: Array.isArray(subtask.acceptanceCriteria) ? subtask.acceptanceCriteria.filter((value) => typeof value === "string") : [],
+      suggestedArtifacts: Array.isArray(subtask.suggestedArtifacts) ? subtask.suggestedArtifacts.filter((value) => typeof value === "string") : [],
+      dependsOn: Array.isArray(subtask.dependsOn) ? subtask.dependsOn.filter((value) => typeof value === "string") : Array.isArray(subtask.dependencies) ? subtask.dependencies.filter((value) => typeof value === "string") : []
+    });
+  }
+  const reasoning = typeof record.reasoning === "string" ? record.reasoning.trim() : "";
+  const agentCount = typeof record.agentCount === "number" && Number.isFinite(record.agentCount) ? Math.max(1, Math.round(record.agentCount)) : void 0;
+  if (!reasoning || subtasks.length === 0) return null;
+  return { reasoning, agentCount, subtasks };
+}
+function buildDecompositionPrompt(params) {
+  const { task, domain, requestedAgents, explicitRoles, classicPathHint } = params;
+  const roleOverrideSection = explicitRoles && explicitRoles.length > 0 ? `
+Explicit role override: use these roles exactly and preserve their order:
+${explicitRoles.map((role, index) => `${index + 1}. ${role}`).join("\n")}` : "";
+  const agentConstraint = typeof requestedAgents === "number" && Number.isFinite(requestedAgents) ? `
+Target agent count: ${requestedAgents}` : `
+Target agent count: infer the smallest useful number, capped at ${DEFAULT_DYNAMIC_AGENT_CAP}`;
+  return [
+    "You are the Swarm Decomposition Supervisor.",
+    "Your job is to turn the task into a small set of specialist agents with concrete mandates.",
+    "Do not force backend/frontend/testing/documentation roles unless the task and project are clearly a classic web app implementation.",
+    "Choose role names that describe the actual work, using arbitrary strings if needed.",
+    "Each subtask must be self-contained, specific, and actionable.",
+    "Return JSON only with this structure:",
+    "{",
+    '  "reasoning": "brief explanation",',
+    '  "agentCount": 3,',
+    '  "subtasks": [',
+    "    {",
+    '      "role": "researcher",',
+    '      "summary": "short label",',
+    '      "objective": "specific mandate",',
+    '      "acceptanceCriteria": ["..."],',
+    '      "suggestedArtifacts": ["..."],',
+    '      "dependsOn": ["other-role"]',
+    "    }",
+    "  ]",
+    "}",
+    "Rules:",
+    "- Prefer 1-3 agents for narrow analysis tasks unless the task is clearly broader.",
+    "- Prefer 3-5 agents for substantial implementation work if the project context supports it.",
+    "- Use analysis/research/synthesis roles for comparison, audit, and market work.",
+    "- Use architect/implementer/verifier/synthesizer roles for implementation work when appropriate.",
+    "- Keep dependencies minimal and only add them when one role truly needs another role\u2019s output.",
+    "- Make mandates specific enough that another agent can execute them without further clarification.",
+    `Classic web-app fast path candidate: ${classicPathHint ? "yes" : "no"}.`,
+    `Task:
+${task}`,
+    `Project context:
+${summarizeProjectDomain(domain)}`,
+    roleOverrideSection,
+    agentConstraint,
+    "Use the project context to determine the right number of agents and the right role specializations."
+  ].filter((section) => section.length > 0).join("\n\n");
+}
+function buildRepairPrompt(prompt, parseError) {
+  return [
+    prompt,
+    "The previous response could not be parsed as valid JSON.",
+    `Parse error: ${parseError}`,
+    "Return ONLY valid JSON matching the requested schema. No markdown. No code fences. No commentary."
+  ].join("\n\n");
+}
+function extractJsonPayload(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) return trimmed;
+  const codeBlockMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (codeBlockMatch?.[1]) {
+    return codeBlockMatch[1].trim();
+  }
+  return trimmed;
+}
+var DomainAwareSwarmPlanner = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  async analyzeDomain(projectPath) {
+    const resolvedPath = path.resolve(projectPath);
+    const capabilities = detectProjectCapabilities(resolvedPath);
+    const isNodeTarget = isNodeLikeProject(capabilities);
+    const packageJson = isNodeTarget ? await readJson(path.join(resolvedPath, "package.json")) : null;
+    const survey = await surveyDirectory(
+      resolvedPath,
+      this.options.scanDepth ?? DEFAULT_SCAN_DEPTH
+    );
+    const frameworks = isNodeTarget ? detectFrameworks(packageJson, survey) : [];
+    const hasFrontend = survey.frontend.size > 0 || frameworks.some((fw) => fw.includes("React") || fw.includes("Next"));
+    const hasBackend = survey.backend.size > 0 || frameworks.some((fw) => ["Express", "Fastify", "NestJS"].includes(fw));
+    const resolverHasTestCommand = capabilities.verification.test.length > 0;
+    const hasTests = resolverHasTestCommand || survey.testFiles > 0 || frameworks.includes("Automated Tests");
+    const hasDocs = survey.docFiles > 0;
+    const techStack = [];
+    if (capabilities.languages.length > 0) {
+      techStack.push(...capabilities.languages.map((language) => `Language: ${language}`));
+    }
+    if (isNodeTarget) {
+      if (packageJson?.name && typeof packageJson.name === "string") {
+        techStack.push(`Package: ${packageJson.name}`);
+      }
+      if (packageJson?.scripts && typeof packageJson.scripts === "object") {
+        techStack.push("npm scripts");
+      }
+    }
+    for (const buildCommand of capabilities.verification.build) {
+      const tool = buildCommand.trim().split(/\s+/)[0];
+      if (tool && !isNodeTarget) techStack.push(`Build: ${tool}`);
+    }
+    if (frameworks.length > 0) {
+      techStack.push(...frameworks);
+    }
+    const notes = [];
+    const isUnknownTarget = capabilities.languages.length === 0 || capabilities.languages.every((language) => language === "unknown");
+    if (isUnknownTarget) {
+      notes.push(
+        "Project language/toolchain could not be detected; treat domain analysis as language-agnostic and verify with the target project conventions."
+      );
+    }
+    if (!hasTests) {
+      notes.push("Test suite not detected; testing agent should bootstrap infrastructure.");
+    }
+    if (!hasDocs) {
+      notes.push(
+        "Documentation directory not found; documentation agent should create baseline docs."
+      );
+    }
+    try {
+      const packagesDir = path.join(resolvedPath, "packages");
+      const pkStat = await statSafe(packagesDir);
+      if (pkStat?.isDirectory()) {
+        const entries = await fs.readdir(packagesDir).catch(() => []);
+        let packageCount = 0;
+        for (const entry of entries) {
+          const pkgPath = path.join(packagesDir, entry, "package.json");
+          const st = await statSafe(pkgPath);
+          if (st) packageCount += 1;
+          if (packageCount >= 2) break;
+        }
+        if (packageCount >= 2) {
+          notes.push("Monorepo structure detected under packages/ directory.");
+        }
+      }
+    } catch {
+    }
+    return {
+      rootPath: resolvedPath,
+      techStack: Array.from(new Set(techStack)),
+      // Prefer the resolver's detected languages; fall back to the file-extension
+      // survey only when the resolver could not classify the target.
+      languages: isUnknownTarget ? Array.from(survey.languages) : Array.from(capabilities.languages),
+      frameworks,
+      hasFrontend,
+      hasBackend,
+      hasTests,
+      hasDocs,
+      inferredServices: Array.from(
+        /* @__PURE__ */ new Set([...Array.from(survey.frontend), ...Array.from(survey.backend)])
+      ),
+      directories: {
+        frontend: Array.from(survey.frontend),
+        backend: Array.from(survey.backend),
+        tests: Array.from(survey.tests),
+        docs: Array.from(survey.docs)
+      },
+      metrics: {
+        totalFiles: survey.totalFiles,
+        codeFiles: survey.codeFiles,
+        testFiles: survey.testFiles,
+        docFiles: survey.docFiles,
+        truncatedDirectoryEntries: survey.truncatedDirectoryEntries > 0 ? survey.truncatedDirectoryEntries : void 0
+      },
+      notes
+    };
+  }
+  async decomposeTask(task, domain, options = {}) {
+    const normalizedTask = task.trim();
+    const explicitRoles = dedupeStrings(options.roles ?? []).map(
+      (role) => normalizeRoleName(role) || role
+    );
+    if (shouldUseClassicWebAppFastPath(normalizedTask, domain, {
+      agents: options.agents,
+      roles: explicitRoles
+    })) {
+      return buildClassicWebAppPlan(normalizedTask, domain);
+    }
+    const planningMode = explicitRoles.length > 0 ? "explicit" : "dynamic";
+    const classicPathHint = isClassicWebAppProject(domain);
+    const prompt = buildDecompositionPrompt({
+      task: normalizedTask,
+      domain,
+      requestedAgents: explicitRoles.length > 0 ? explicitRoles.length : options.agents ?? estimateDynamicAgentCount(normalizedTask, domain),
+      explicitRoles: explicitRoles.length > 0 ? explicitRoles : void 0,
+      classicPathHint
+    });
+    if (!options.dryRun) {
+      const providerPlan = await this.tryLLMDecomposition(normalizedTask, domain, prompt, {
+        agents: options.agents,
+        roles: explicitRoles.length > 0 ? explicitRoles : void 0,
+        planningMode
+      });
+      if (providerPlan) {
+        return providerPlan;
+      }
+    }
+    return this.buildHeuristicPlan(normalizedTask, domain, {
+      agents: options.agents,
+      roles: explicitRoles,
+      planningMode
+    });
+  }
+  async tryLLMDecomposition(task, domain, prompt, options) {
+    if (process.env.NODE_ENV === "test" || process.env.VITEST === "true") {
+      return null;
+    }
+    const resolvedConfig = resolveConfig(void 0, domain.rootPath);
+    const provider = resolvedConfig.defaultProvider.value;
+    const model = resolvedConfig.defaultModel.value;
+    if (!provider || !model) {
+      return null;
+    }
+    try {
+      const result = await runProviderNative({
+        provider,
+        model,
+        workingDir: domain.rootPath,
+        prompt,
+        executionIntent: "analysis",
+        strategy: "conservative",
+        timeoutMs: 6e4
+      });
+      if (result.exitCode !== void 0 && result.exitCode !== 0 || !result.stdout?.trim()) {
+        return null;
+      }
+      const parsed = this.parseLLMResponse(result.stdout);
+      if (!parsed) {
+        const repairResult = await runProviderNative({
+          provider,
+          model,
+          workingDir: domain.rootPath,
+          prompt: buildRepairPrompt(
+            prompt,
+            "The previous response was not valid JSON or did not match the schema."
+          ),
+          executionIntent: "analysis",
+          strategy: "conservative",
+          timeoutMs: 6e4
+        });
+        if (repairResult.exitCode !== void 0 && repairResult.exitCode !== 0 || !repairResult.stdout?.trim()) {
+          return null;
+        }
+        const repaired = this.parseLLMResponse(repairResult.stdout);
+        if (!repaired) {
+          return null;
+        }
+        const normalizedSpecs2 = this.normalizeRoleSpecs(
+          task,
+          repaired,
+          options.roles,
+          options.agents
+        );
+        if (!normalizedSpecs2 || normalizedSpecs2.length === 0) {
+          return null;
+        }
+        return buildDynamicPlanFromSpecs(
+          task,
+          domain,
+          normalizedSpecs2,
+          options.planningMode,
+          repaired.reasoning || "LLM decomposition completed successfully."
+        );
+      }
+      const normalizedSpecs = this.normalizeRoleSpecs(task, parsed, options.roles, options.agents);
+      if (!normalizedSpecs || normalizedSpecs.length === 0) {
+        return null;
+      }
+      const mode = options.planningMode;
+      const reasoning = parsed.reasoning || "LLM decomposition completed successfully.";
+      return buildDynamicPlanFromSpecs(task, domain, normalizedSpecs, mode, reasoning);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (isDebugMode()) {
+        console.warn(chalk.gray(`[Swarm planner] LLM decomposition fallback: ${message}`));
+      }
+      return null;
+    }
+  }
+  parseLLMResponse(raw) {
+    try {
+      const extracted = extractJsonPayload(raw);
+      let candidate;
+      try {
+        candidate = parseJsonWithContext(
+          extracted,
+          "Swarm decomposition response"
+        );
+      } catch {
+        const objectMatch = extracted.match(/(\{[\s\S]*\})/);
+        if (!objectMatch?.[1]) {
+          return null;
+        }
+        candidate = parseJsonWithContext(
+          objectMatch[1],
+          "Swarm decomposition response"
+        );
+      }
+      return parseRoleSpecs(candidate);
+    } catch {
+      return null;
+    }
+  }
+  normalizeRoleSpecs(task, parsed, explicitRoles, requestedAgents) {
+    const specs = parsed.subtasks.slice();
+    const normalizedExplicitRoles = explicitRoles?.map((role) => normalizeRoleName(role) || role);
+    if (normalizedExplicitRoles && normalizedExplicitRoles.length > 0) {
+      return normalizedExplicitRoles.map((role, index) => {
+        const spec = specs[index];
+        const objective = spec?.objective ?? `Execute the ${role} portion of the task with a concrete, role-specific mandate.`;
+        return {
+          role,
+          summary: spec?.summary ?? humanizeRole(role),
+          objective,
+          acceptanceCriteria: spec?.acceptanceCriteria ?? [],
+          suggestedArtifacts: spec?.suggestedArtifacts ?? [],
+          dependsOn: spec?.dependsOn ?? []
+        };
+      });
+    }
+    const limit = typeof requestedAgents === "number" && Number.isFinite(requestedAgents) ? requestedAgents : parsed.agentCount ?? specs.length;
+    const targetCount = Math.max(1, Math.round(limit));
+    const normalized = specs.slice(0, targetCount);
+    const fillerRoles = isAnalysisTask(task) ? targetCount === 1 ? ["researcher"] : targetCount === 2 ? ["researcher", "synthesizer"] : padRoleNames(
+      ["researcher", "analyst", "synthesizer"],
+      targetCount,
+      ["reviewer", "fact-checker", "source-curator"],
+      "research-role"
+    ) : targetCount === 1 ? ["implementer"] : targetCount === 2 ? ["architect", "implementer"] : targetCount === 3 ? ["architect", "implementer", "verifier"] : padRoleNames(
+      ["architect", "implementer", "verifier", "synthesizer"],
+      targetCount,
+      ["integrator", "release-manager", "stabilizer"],
+      "implementation-role"
+    );
+    while (normalized.length < targetCount) {
+      const index = normalized.length;
+      const role = fillerRoles[index] ?? `${isAnalysisTask(task) ? "research-role" : "implementation-role"}-${index + 1}`;
+      normalized.push({
+        role,
+        summary: humanizeRole(role),
+        objective: `Complete the ${role} portion of "${task.trim()}" with a clear, role-specific mandate.`,
+        acceptanceCriteria: [
+          "Role-specific deliverable produced",
+          "Work is aligned with the task context"
+        ],
+        suggestedArtifacts: ["handoff-notes.md"],
+        dependsOn: index === 0 ? [] : [normalized[0]?.role ?? role]
+      });
+    }
+    return normalized;
+  }
+  buildHeuristicPlan(task, domain, options) {
+    const hasAnalysisSignals = isAnalysisTask(task);
+    const explicitRoles = options.roles && options.roles.length > 0 ? options.roles : void 0;
+    if (hasAnalysisSignals) {
+      const plan2 = synthesizeAnalysisPlan(
+        task,
+        domain,
+        options.agents,
+        explicitRoles,
+        options.planningMode
+      );
+      return {
+        ...plan2,
+        planningMode: options.planningMode
+      };
+    }
+    const plan = synthesizeImplementationPlan(
+      task,
+      domain,
+      options.agents,
+      explicitRoles,
+      options.planningMode
+    );
+    return {
+      ...plan,
+      planningMode: options.planningMode
+    };
+  }
+  async validateDependencies(plan) {
+    return inferDependencies(plan.subtasks);
+  }
+};
+
+export {
+  getDecompositionRecoveryPlan,
+  filterAvailable,
+  selectNext,
+  DomainAwareSwarmPlanner
+};
+//# sourceMappingURL=chunk-HQXYYUNY.js.map