@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/plan-to-flywheel-PY5MSY2H.js

@@ -0,0 +1,529 @@
+import {
+  applyExecutionPolicyToGeneratedWorkflow,
+  createDefaultCompetitionConfig,
+  resolveStageContract
+} from "./chunk-MO2BYAAF.js";
+import "./chunk-JHP7OT6K.js";
+import "./chunk-G6OIMVXH.js";
+import "./chunk-JDCZQZU7.js";
+import "./chunk-YTVVTIWJ.js";
+import "./chunk-HBZ322WZ.js";
+import "./chunk-R2W3LESH.js";
+import "./chunk-GAB6UW52.js";
+import "./chunk-UKMPASIC.js";
+import "./chunk-SU6UFUQY.js";
+import "./chunk-INJ3SS6A.js";
+import "./chunk-LDJCKAJP.js";
+import "./chunk-7SEWU4QG.js";
+import "./chunk-7LHJDJB3.js";
+import "./chunk-2KO7HVZM.js";
+import "./chunk-UAPHFJPN.js";
+import "./chunk-6T6NHXK4.js";
+import "./chunk-R5EXHMUN.js";
+import "./chunk-NAINGKHF.js";
+import "./chunk-US3RT6CY.js";
+import "./chunk-GI5M67YA.js";
+import {
+  extractAcceptanceCriteria
+} from "./chunk-XON4ZCYX.js";
+import "./chunk-PPHXX4W7.js";
+import "./chunk-NXH3RX7O.js";
+import "./chunk-EJVCDTAN.js";
+import "./chunk-ETA2K4KI.js";
+import "./chunk-MCBNWZNO.js";
+import "./chunk-J2QCFLUN.js";
+import "./chunk-CSXLLEGB.js";
+import "./chunk-LJVH57G2.js";
+import "./chunk-VAG6GUBR.js";
+import "./chunk-P5P2EKGH.js";
+import "./chunk-6G57FYBV.js";
+import "./chunk-AJBTKGJZ.js";
+import "./chunk-V3KLVK7B.js";
+import "./chunk-TDSEX5CF.js";
+import "./chunk-7KBEOPVB.js";
+import "./chunk-32IYXIE5.js";
+import "./chunk-7RMARDVH.js";
+import "./chunk-HXIIEMGF.js";
+import "./chunk-6TRD7TEE.js";
+import "./chunk-GZAJHLKO.js";
+import "./chunk-ZJB6SQPA.js";
+import "./chunk-C3DH3NCY.js";
+import "./chunk-IVZEONFC.js";
+import "./chunk-XTXYIISX.js";
+import "./chunk-MEMSY6VY.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-33IGPPUI.js";
+import "./chunk-UPHU64NB.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-FRBPKBFE.js";
+import "./chunk-BAWJNMWF.js";
+import "./chunk-LX4F24ZH.js";
+import "./chunk-BBPIILO2.js";
+import "./chunk-2NMNFUQA.js";
+import "./chunk-I7SCBHJN.js";
+import "./chunk-TGXXYDL4.js";
+import "./chunk-D2M2Y5ID.js";
+import "./chunk-UJP3XM54.js";
+import "./chunk-MULMXX4V.js";
+import "./chunk-UTDEOPKV.js";
+import "./chunk-RFDVSI4N.js";
+import "./chunk-M4BUEXXF.js";
+import "./chunk-ZH4G3FU5.js";
+import "./chunk-726G6WDL.js";
+import "./chunk-7HPCIOMA.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-XQPEWJPI.js";
+import "./chunk-6TBEX4R4.js";
+import "./chunk-PXKERBKX.js";
+import "./chunk-QYQOVOLR.js";
+import "./chunk-SVUNZOPG.js";
+import "./chunk-KUEWV2JH.js";
+import "./chunk-R2TIYG7U.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-3H4MWYIC.js";
+import "./chunk-DP7FKP6W.js";
+import "./chunk-XGU6PBO5.js";
+import "./chunk-F55YABKV.js";
+import "./chunk-D6WTZMZB.js";
+import "./chunk-RBBTBCHX.js";
+import "./chunk-4DJL2VXA.js";
+import "./chunk-AHU3FKPA.js";
+import "./chunk-TUQMMFEQ.js";
+import "./chunk-EPAMVGI3.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-L2S235CU.js";
+import "./chunk-D4VJFCGZ.js";
+import "./chunk-RPIMAMV7.js";
+import "./chunk-ALDTFNZ3.js";
+import "./chunk-QOIASNEJ.js";
+import "./chunk-2VUEDIUM.js";
+import "./chunk-MJ6WNSIX.js";
+import "./chunk-5KQETTNS.js";
+import "./chunk-J2ICMYDA.js";
+import "./chunk-2VLJUXJU.js";
+import "./chunk-PPZESPJT.js";
+import "./chunk-XCOIBNET.js";
+import "./chunk-Y733RB7T.js";
+import "./chunk-H3HGMISG.js";
+import "./chunk-FAZBRHGG.js";
+import "./chunk-CJBSZX3F.js";
+import "./chunk-C3KCMAJP.js";
+import "./chunk-FKCG7K6H.js";
+import "./chunk-AJN5Y5YZ.js";
+import "./chunk-MHLEZQQI.js";
+import "./chunk-HEP3ILP4.js";
+import "./chunk-BQJOGAWT.js";
+import "./chunk-WV3KQDPE.js";
+import "./chunk-VSWC5ZXI.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-KKQKWAMF.js";
+import "./chunk-RWQQIKIC.js";
+import "./chunk-GVJGSSKM.js";
+import "./chunk-QJ6OEH4K.js";
+import "./chunk-BD3PGW6A.js";
+import "./chunk-43OKHTW4.js";
+import "./chunk-MNOVBYFU.js";
+import "./chunk-QXBKTJT6.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-35J4NE6S.js";
+import "./chunk-RIMARPCF.js";
+import "./chunk-HGFXODKO.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-V2TVPO3X.js";
+import "./chunk-RRC5BL7B.js";
+import "./chunk-352PCJLK.js";
+import "./chunk-RCP2Y6DQ.js";
+import "./chunk-M6UHOC4I.js";
+import "./chunk-3JKNRYEE.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-WGQAXLNA.js";
+import "./chunk-ONHAMBN6.js";
+import "./chunk-XSJTIFUY.js";
+import "./chunk-XWIZ6B5S.js";
+import "./chunk-U4DRS6ZW.js";
+import "./chunk-I56TH7VM.js";
+import "./chunk-Z5WGNULV.js";
+import "./chunk-O26L6F7F.js";
+import "./chunk-RJ6RSNT6.js";
+import "./chunk-ZORW64QH.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/planning/plan-to-flywheel.ts
+var CRITICAL_KEYWORDS = [
+  "auth",
+  "security",
+  "database",
+  "schema",
+  "migration",
+  "payment",
+  "api",
+  "core"
+];
+var FALLBACK_STAGES = [
+  {
+    title: "Plan & Design",
+    description: "Analyze requirements and design solution approach",
+    isCritical: false,
+    estimatedComplexity: 0.3
+  },
+  {
+    title: "Implementation",
+    description: "Implement core functionality",
+    isCritical: true,
+    estimatedComplexity: 0.6
+  },
+  {
+    title: "Validation & Testing",
+    description: "Verify implementation with tests and quality checks",
+    isCritical: false,
+    estimatedComplexity: 0.4
+  }
+];
+function compileWorkItemToWorkflow(workItem, options = {}) {
+  const warnings = [];
+  const parsed = parseWorkItemContent(workItem);
+  const stages = parsed.length > 0 ? parsed : FALLBACK_STAGES;
+  const usedFallback = parsed.length === 0;
+  const metadataExecutionIntent = normalizeWorkItemExecutionIntent(
+    workItem.metadata?.executionIntent
+  );
+  const rootContract = resolveStageContract({
+    title: workItem.title,
+    text: workItem.description,
+    ...metadataExecutionIntent ? { metadataExecutionIntent } : {}
+  });
+  if (usedFallback) {
+    warnings.push("No explicit task structure found; using fallback 3-stage template");
+  }
+  const limitedStages = options.maxStages ? stages.slice(0, options.maxStages) : stages;
+  if (options.maxStages && stages.length > options.maxStages) {
+    warnings.push(
+      `Limiting to ${options.maxStages} stages (${stages.length - options.maxStages} stages omitted)`
+    );
+  }
+  const stageConfigs = [];
+  let frontier = [];
+  let activeParallelGroup;
+  let activeParallelMembers = [];
+  for (let index = 0; index < limitedStages.length; index++) {
+    const stage = limitedStages[index];
+    if (!stage) continue;
+    const stageId = `stage-${index + 1}`;
+    const rootReadOnly = rootContract.authoritativeAnalysis && rootContract.capabilities.executionIntent === "analysis";
+    const stageContract = resolveStageContract({
+      title: stage.title,
+      text: stage.description,
+      ...rootReadOnly ? { metadataExecutionIntent: "analysis" } : {}
+    });
+    const stagePrompt = [
+      `# Work item: ${workItem.title}`,
+      workItem.description,
+      `# Assigned stage: ${stage.title}`,
+      stage.description,
+      "Perform only the assigned stage, using the full work item as requirements and context."
+    ].filter(Boolean).join("\n\n");
+    const stageConfig = {
+      id: stageId,
+      name: stage.title,
+      prompt: stagePrompt,
+      templateVariables: {
+        reviewAcceptanceCriteria: extractAcceptanceCriteria(stage.description, {
+          checkboxFallback: false
+        })
+      },
+      provider: options.provider,
+      model: options.model,
+      capabilities: stageContract.capabilities
+    };
+    const { strategy, reason } = selectStageStrategy(stage);
+    if (strategy === "compete") {
+      stageConfig.type = "competition";
+      stageConfig.competition = createCompetitionConfig(stage, options.provider);
+      stageConfig.prompt = `${stagePrompt}
+
+<!-- Strategy: ${reason} -->`;
+    } else {
+      stageConfig.type = "standard";
+      stageConfig.prompt = `${stagePrompt}
+
+<!-- Strategy: ${reason} -->`;
+    }
+    if (!stage.parallelGroup && activeParallelGroup) {
+      frontier = activeParallelMembers;
+      activeParallelGroup = void 0;
+      activeParallelMembers = [];
+    }
+    if (frontier.length > 0) {
+      stageConfig.deps = [...frontier];
+    }
+    if (stage.parallelGroup) {
+      if (!activeParallelGroup) {
+        activeParallelGroup = stage.parallelGroup;
+        activeParallelMembers = [];
+      } else if (activeParallelGroup !== stage.parallelGroup) {
+        frontier = activeParallelMembers;
+        activeParallelGroup = stage.parallelGroup;
+        activeParallelMembers = [];
+        stageConfig.deps = [...frontier];
+      }
+      activeParallelMembers.push(stageId);
+    } else {
+      frontier = [stageId];
+    }
+    stageConfigs.push(stageConfig);
+  }
+  const workflow = {
+    name: `Execution: ${workItem.title}`,
+    stages: stageConfigs
+  };
+  if (options.strict) {
+    workflow.strict = { requireExplicitDeps: true };
+    for (const stage of stageConfigs) {
+      if (!stage.deps) {
+        stage.deps = [];
+      }
+    }
+  }
+  if (options.dryRun) {
+    warnings.push("Dry-run: workflow compiled for inspection only (not executed by this compiler)");
+  }
+  const stampedWorkflow = applyExecutionPolicyToGeneratedWorkflow(workflow, {
+    ...options.provider ? { cliProviderOverride: options.provider } : {},
+    ...options.reviewPolicy ? { reviewPolicy: options.reviewPolicy } : {},
+    warnings
+  });
+  return {
+    workflow: stampedWorkflow,
+    warnings,
+    usedFallback
+  };
+}
+function normalizeWorkItemExecutionIntent(value) {
+  if (value === "analysis" || value === "edit") {
+    return value;
+  }
+  return void 0;
+}
+function parseWorkItemContent(workItem) {
+  const content = typeof workItem.description === "string" ? workItem.description : "";
+  const stages = [];
+  const checklistItems = parseChecklistsWithParallelGroups(content);
+  if (checklistItems.length > 0) {
+    for (const item of checklistItems) {
+      stages.push({
+        title: item.title,
+        description: item.description || item.title,
+        isCritical: isCriticalTask(item.title),
+        estimatedComplexity: estimateComplexity(item.title),
+        parallelGroup: item.parallelGroup
+      });
+    }
+    return stages;
+  }
+  const headings = parseHeadings(content);
+  if (headings.length > 0) {
+    for (const heading of headings) {
+      stages.push({
+        title: heading.title,
+        description: heading.content || heading.title,
+        isCritical: isCriticalTask(heading.title),
+        estimatedComplexity: estimateComplexity(heading.title)
+      });
+    }
+    return stages;
+  }
+  return [];
+}
+function parseChecklistsWithParallelGroups(content) {
+  const items = [];
+  const lines = content.split("\n");
+  const parallelSectionRegex = /^##\s+(Fanout|Parallel)/i;
+  const sectionRegex = /^##\s+(.+)$/;
+  const checklistRegex = /^[-*]\s+\[ \]\s+(.+)$/;
+  let currentParallelGroup;
+  let parallelGroupCounter = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (currentParallelGroup && trimmed.length === 0) {
+      currentParallelGroup = void 0;
+      continue;
+    }
+    const parallelMatch = trimmed.match(parallelSectionRegex);
+    if (parallelMatch) {
+      parallelGroupCounter++;
+      currentParallelGroup = `parallel-${parallelGroupCounter}`;
+      continue;
+    }
+    const sectionMatch = trimmed.match(sectionRegex);
+    if (sectionMatch && !parallelMatch) {
+      currentParallelGroup = void 0;
+      continue;
+    }
+    const checklistMatch = trimmed.match(checklistRegex);
+    if (checklistMatch) {
+      const title = checklistMatch[1]?.trim();
+      if (title) {
+        items.push({
+          title,
+          parallelGroup: currentParallelGroup
+        });
+      }
+    }
+  }
+  return items;
+}
+function parseHeadings(content) {
+  const headings = [];
+  const lines = content.split("\n");
+  const headingRegex = /^(#{2,4})\s+(.+)$/;
+  let currentHeading = null;
+  let contentLines = [];
+  for (const line of lines) {
+    const match = line.trim().match(headingRegex);
+    if (match) {
+      if (currentHeading) {
+        currentHeading.content = contentLines.join("\n").trim();
+        headings.push(currentHeading);
+        contentLines = [];
+      }
+      const level = match[1]?.length || 2;
+      const title = match[2]?.trim();
+      if (title) {
+        currentHeading = { title, content: "", level };
+      }
+    } else if (currentHeading && line.trim()) {
+      contentLines.push(line);
+    }
+  }
+  if (currentHeading) {
+    currentHeading.content = contentLines.join("\n").trim();
+    headings.push(currentHeading);
+  }
+  return headings.filter((h) => h.level === 2 || h.level === 3);
+}
+function isCriticalTask(title) {
+  const normalized = title.toLowerCase();
+  return CRITICAL_KEYWORDS.some((keyword) => normalized.includes(keyword));
+}
+function estimateComplexity(title) {
+  let score = 0.3;
+  if (isCriticalTask(title)) {
+    score += 0.2;
+  }
+  const wordCount = title.split(/\s+/).length;
+  if (wordCount > 10) {
+    score += 0.1;
+  }
+  return Math.min(score, 0.8);
+}
+function selectStageStrategy(stage) {
+  if (stage.isCritical) {
+    return {
+      strategy: "compete",
+      reason: `Critical stage (${stage.title}): Benefits from multi-variant competition`
+    };
+  }
+  if (stage.estimatedComplexity > 0.5) {
+    return {
+      strategy: "compete",
+      reason: `High complexity (${stage.estimatedComplexity.toFixed(2)}): Competition for quality assurance`
+    };
+  }
+  const analysisKeywords = ["plan", "design", "analyze", "research", "investigate", "review"];
+  const normalizedTitle = stage.title.toLowerCase();
+  if (analysisKeywords.some((kw) => normalizedTitle.includes(kw))) {
+    return {
+      strategy: "single-pass",
+      reason: "Analysis-oriented stage: Single provider sufficient"
+    };
+  }
+  if (stage.estimatedComplexity <= 0.3) {
+    return {
+      strategy: "single-pass",
+      reason: "Low complexity: Single provider sufficient"
+    };
+  }
+  return {
+    strategy: "compete",
+    reason: "Default: Competition for quality assurance"
+  };
+}
+function createCompetitionConfig(_stage, provider) {
+  return createDefaultCompetitionConfig(provider);
+}
+function visualizeWorkflow(workflow) {
+  const lines = [];
+  lines.push(`Workflow: ${workflow.name || "Unnamed"}`);
+  lines.push("-".repeat(60));
+  lines.push("");
+  const parallelGroups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < workflow.stages.length; i++) {
+    const stage = workflow.stages[i];
+    if (!stage) continue;
+    const deps = stage.deps || [];
+    const depsKey = deps.join(",");
+    if (i > 0 && deps.length > 0) {
+      const prevStage = workflow.stages[i - 1];
+      const prevDeps = prevStage?.deps || [];
+      const prevDepsKey = prevDeps.join(",");
+      if (depsKey === prevDepsKey && depsKey !== "") {
+        let group = parallelGroups.get(depsKey);
+        if (!group) {
+          group = [i - 1];
+          parallelGroups.set(depsKey, group);
+        }
+        group.push(i);
+      }
+    }
+  }
+  let currentParallelGroup;
+  for (let i = 0; i < workflow.stages.length; i++) {
+    const stage = workflow.stages[i];
+    if (!stage) continue;
+    const stageType = stage.type === "competition" ? "Competition" : "Standard";
+    const stageName = stage.name || stage.id;
+    const isFirstInGroup = Array.from(parallelGroups.values()).some(
+      (group) => group[0] === i && group.length > 1
+    );
+    if (isFirstInGroup) {
+      currentParallelGroup = Array.from(parallelGroups.values()).find((group) => group[0] === i);
+      lines.push("  +-- PARALLEL ----------------");
+    }
+    const indent = currentParallelGroup?.includes(i) ? "  | " : "";
+    lines.push(`${indent}Stage ${i + 1}: ${stageName}`);
+    lines.push(`${indent}  Type: ${stageType}`);
+    lines.push(`${indent}  ID: ${stage.id}`);
+    if (stage.competition) {
+      const variantCount = stage.competition.variants.length;
+      lines.push(`${indent}  Variants: ${variantCount}`);
+    }
+    if (stage.deps && stage.deps.length > 0) {
+      lines.push(`${indent}  Dependencies: ${stage.deps.join(", ")}`);
+    }
+    const isLastInGroup = currentParallelGroup && currentParallelGroup[currentParallelGroup.length - 1] === i;
+    if (isLastInGroup) {
+      lines.push("  +----------------------------");
+      currentParallelGroup = void 0;
+    }
+    if (i < workflow.stages.length - 1 && !currentParallelGroup) {
+      lines.push("  v");
+    }
+    lines.push("");
+  }
+  lines.push("-".repeat(60));
+  return lines.join("\n");
+}
+export {
+  compileWorkItemToWorkflow,
+  visualizeWorkflow
+};
+//# sourceMappingURL=plan-to-flywheel-PY5MSY2H.js.map

package/dist/preflight-PJHGTJNZ.js

@@ -0,0 +1,12 @@
+import {
+  evaluateCursorConfigWriteRestrictions,
+  formatCursorExecutionPreflightFailure,
+  runCursorExecutionPreflight
+} from "./chunk-HS3SY6HN.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  evaluateCursorConfigWriteRestrictions,
+  formatCursorExecutionPreflightFailure,
+  runCursorExecutionPreflight
+};
+//# sourceMappingURL=preflight-PJHGTJNZ.js.map

package/dist/process-registry-B4ZUCN7T.js

@@ -0,0 +1,28 @@
+import {
+  ProcessRegistry,
+  RegistryStateAccessError,
+  __testOnlyGetRegistryPathMutexCount,
+  getProcessRegistryStateDirectory,
+  processRegistry
+} from "./chunk-QP5ST7RI.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ProcessRegistry,
+  RegistryStateAccessError,
+  __testOnlyGetRegistryPathMutexCount,
+  getProcessRegistryStateDirectory,
+  processRegistry
+};
+//# sourceMappingURL=process-registry-B4ZUCN7T.js.map

package/dist/process-scanner-TU3QHWVB.js

@@ -0,0 +1,23 @@
+import {
+  ProcessScanner,
+  processScanner
+} from "./chunk-47X5LM7B.js";
+import "./chunk-QP5ST7RI.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ProcessScanner,
+  processScanner
+};
+//# sourceMappingURL=process-scanner-TU3QHWVB.js.map

package/dist/processes-6FHVGT72.js

@@ -0,0 +1,28 @@
+import {
+  processesCommand
+} from "./chunk-IUKOPCCE.js";
+import "./chunk-OC7Z6AJQ.js";
+import "./chunk-47X5LM7B.js";
+import "./chunk-QP5ST7RI.js";
+import "./chunk-B7PYTV72.js";
+import "./chunk-5AW4RMNG.js";
+import "./chunk-Y4ZDDHB6.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-O5X6BKAO.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-6CB3KJRY.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  processesCommand
+};
+//# sourceMappingURL=processes-6FHVGT72.js.map

package/dist/processes-json-fast-YWTMUWXB.js

@@ -0,0 +1,72 @@
+import {
+  filterProcessEntries,
+  formatRegistryAccessErrorJson,
+  validateProcessAction,
+  validateProcessFilters
+} from "./chunk-OC7Z6AJQ.js";
+import {
+  processScanner
+} from "./chunk-47X5LM7B.js";
+import {
+  RegistryStateAccessError,
+  processRegistry
+} from "./chunk-QP5ST7RI.js";
+import "./chunk-5AW4RMNG.js";
+import {
+  ExitCodeError,
+  isExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import "./chunk-P6SSWAKY.js";
+import "./chunk-ETAD4NKD.js";
+import "./chunk-XJ2E7YEJ.js";
+import "./chunk-MT2WAIR3.js";
+import "./chunk-56WPYDJH.js";
+import "./chunk-RSYTSBOO.js";
+import "./chunk-STW7OFOA.js";
+import "./chunk-CHA2HDE5.js";
+import "./chunk-JNMWYMC6.js";
+import "./chunk-7VRJHTGZ.js";
+import "./chunk-XDM65LBX.js";
+import "./chunk-CPSVQR2I.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/cli/commands/processes-json-fast.ts
+import { Command } from "commander";
+function validateRequestedAction(actionArg, options) {
+  const optionActions = [];
+  if (options.list) optionActions.push("list");
+  if (options.scan) optionActions.push("scan");
+  return validateProcessAction(actionArg, ["list", "scan"], optionActions);
+}
+async function runProcessesJsonFastAction(actionArg, options) {
+  try {
+    const action = validateRequestedAction(actionArg, options);
+    await processRegistry.init();
+    if (action === "scan") {
+      const detected = await processScanner.scan({ includeAll: true });
+      console.log(JSON.stringify(detected, null, 2));
+      return;
+    }
+    await processRegistry.scan();
+    const filters = validateProcessFilters(options);
+    const entries = filterProcessEntries(await processRegistry.getAll(), filters);
+    console.log(JSON.stringify(entries, null, 2));
+  } catch (error) {
+    if (isExitCodeError(error)) {
+      throw error;
+    }
+    if (error instanceof RegistryStateAccessError) {
+      console.log(formatRegistryAccessErrorJson(error));
+      throw new ExitCodeError(1);
+    }
+    throw error;
+  }
+}
+function createProcessesJsonFastCommand() {
+  return new Command("processes").description("List or scan Build processes as JSON").argument("[action]", "Action to run: list or scan").option("-l, --list", "List all managed processes (default)", false).option("--scan", "Scan for all Build processes", false).option("--category <type>", "Filter by category (cli, test, variant, etc.)").option("--type <type>", "Filter by type (spawned, detected, external)").option("--json", "Output as JSON", false).action(runProcessesJsonFastAction);
+}
+export {
+  createProcessesJsonFastCommand,
+  runProcessesJsonFastAction
+};
+//# sourceMappingURL=processes-json-fast-YWTMUWXB.js.map