@automatify-au/cli 0.1.0

package/dist/automatify.js

@@ -0,0 +1,4011 @@
+#!/usr/bin/env node
+
+// src/cliResult.ts
+var ExitCode = {
+  Success: 0,
+  InternalError: 1,
+  UsageError: 2,
+  ValidationError: 3,
+  RemoteError: 4,
+  TransportError: 5
+};
+function toJsonLine(data) {
+  return [JSON.stringify(data)];
+}
+
+// src/auto.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path5 from "node:path";
+
+// ../../packages/shared-types/dist/index.js
+var TestCaseStatus;
+(function(TestCaseStatus2) {
+  TestCaseStatus2["Draft"] = "draft";
+  TestCaseStatus2["Active"] = "active";
+  TestCaseStatus2["Deprecated"] = "deprecated";
+})(TestCaseStatus || (TestCaseStatus = {}));
+var StepResult;
+(function(StepResult2) {
+  StepResult2["Passed"] = "passed";
+  StepResult2["Failed"] = "failed";
+  StepResult2["Skipped"] = "skipped";
+  StepResult2["Blocked"] = "blocked";
+})(StepResult || (StepResult = {}));
+var ExecutionCycleStatus;
+(function(ExecutionCycleStatus2) {
+  ExecutionCycleStatus2["Draft"] = "draft";
+  ExecutionCycleStatus2["Active"] = "active";
+  ExecutionCycleStatus2["Completed"] = "completed";
+  ExecutionCycleStatus2["Archived"] = "archived";
+})(ExecutionCycleStatus || (ExecutionCycleStatus = {}));
+var ExecutionPlanningStatus;
+(function(ExecutionPlanningStatus2) {
+  ExecutionPlanningStatus2["NotRun"] = "notRun";
+  ExecutionPlanningStatus2["InProgress"] = "inProgress";
+  ExecutionPlanningStatus2["Passed"] = "passed";
+  ExecutionPlanningStatus2["Failed"] = "failed";
+  ExecutionPlanningStatus2["Blocked"] = "blocked";
+  ExecutionPlanningStatus2["Skipped"] = "skipped";
+})(ExecutionPlanningStatus || (ExecutionPlanningStatus = {}));
+var Priority;
+(function(Priority2) {
+  Priority2["Low"] = "low";
+  Priority2["Medium"] = "medium";
+  Priority2["High"] = "high";
+})(Priority || (Priority = {}));
+
+// src/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var DEFAULT_CONFIG_FILENAME = ".testops-cli.json";
+function parseFlags(args) {
+  const flags = {};
+  const unknownFlags = [];
+  const supported = /* @__PURE__ */ new Set([
+    "--config",
+    "--base-url",
+    "--project-key",
+    "--issue-key",
+    "--auth-mode",
+    "--jira-email",
+    "--jira-api-token"
+  ]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (!supported.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { flags, unknownFlags };
+}
+function toStringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function readConfigFile(configPath) {
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function normalizeBaseUrl(value) {
+  if (value.endsWith("/")) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function readAuthMode(input) {
+  return input === "api-token" ? "api-token" : "none";
+}
+function valueFromPrecedence(key, flagValue, envValue, fileValue, fallback = "") {
+  if (flagValue) {
+    return { value: flagValue, source: "flag" };
+  }
+  if (envValue) {
+    return { value: envValue, source: "env" };
+  }
+  if (fileValue) {
+    return { value: fileValue, source: "file" };
+  }
+  if (fallback) {
+    return { value: fallback, source: "default" };
+  }
+  return { value: "", source: "default" };
+}
+function resolveCliConfig(args, env = process.env, cwd = process.cwd()) {
+  const { flags, unknownFlags } = parseFlags(args);
+  const configPathFlag = flags["--config"] ? path.resolve(cwd, flags["--config"]) : "";
+  const configPathEnv = toStringValue(env.TESTOPS_CONFIG_PATH);
+  const configPath = configPathFlag || (configPathEnv ? path.resolve(cwd, configPathEnv) : path.resolve(cwd, DEFAULT_CONFIG_FILENAME));
+  const configPathSource = configPathFlag ? "flag" : configPathEnv ? "env" : "default";
+  const file = readConfigFile(configPath);
+  const baseUrlResolved = valueFromPrecedence(
+    "baseUrl",
+    toStringValue(flags["--base-url"]),
+    toStringValue(env.JIRA_BASE_URL),
+    toStringValue(file.baseUrl ?? file.JIRA_BASE_URL)
+  );
+  const projectKeyResolved = valueFromPrecedence(
+    "projectKey",
+    toStringValue(flags["--project-key"]),
+    toStringValue(env.JIRA_PROJECT_KEY),
+    toStringValue(file.projectKey ?? file.JIRA_PROJECT_KEY)
+  );
+  const issueKeyResolved = valueFromPrecedence(
+    "issueKey",
+    toStringValue(flags["--issue-key"]),
+    toStringValue(env.JIRA_ISSUE_KEY),
+    toStringValue(file.issueKey ?? file.JIRA_ISSUE_KEY)
+  );
+  const authModeResolved = valueFromPrecedence(
+    "authMode",
+    toStringValue(flags["--auth-mode"]),
+    toStringValue(env.TESTOPS_AUTH_MODE),
+    toStringValue(file.authMode ?? file.TESTOPS_AUTH_MODE),
+    "none"
+  );
+  const jiraEmailResolved = valueFromPrecedence(
+    "jiraEmail",
+    toStringValue(flags["--jira-email"]),
+    toStringValue(env.JIRA_EMAIL),
+    toStringValue(file.jiraEmail ?? file.JIRA_EMAIL)
+  );
+  const jiraApiTokenResolved = valueFromPrecedence(
+    "jiraApiToken",
+    toStringValue(flags["--jira-api-token"]),
+    toStringValue(env.JIRA_API_TOKEN),
+    toStringValue(file.jiraApiToken ?? file.JIRA_API_TOKEN)
+  );
+  const config = {
+    baseUrl: normalizeBaseUrl(baseUrlResolved.value),
+    projectKey: projectKeyResolved.value,
+    issueKey: issueKeyResolved.value,
+    authMode: readAuthMode(authModeResolved.value),
+    jiraEmail: jiraEmailResolved.value,
+    jiraApiToken: jiraApiTokenResolved.value,
+    configPath
+  };
+  const sources = {
+    baseUrl: baseUrlResolved.source,
+    projectKey: projectKeyResolved.source,
+    issueKey: issueKeyResolved.source,
+    authMode: authModeResolved.source,
+    jiraEmail: jiraEmailResolved.source,
+    jiraApiToken: jiraApiTokenResolved.source,
+    configPath: configPathSource
+  };
+  const warnings = [];
+  if (unknownFlags.length > 0) {
+    warnings.push(`Ignored unknown config flags: ${unknownFlags.join(", ")}`);
+  }
+  if (!existsSync(configPath) && sources.configPath !== "default") {
+    warnings.push(`Config file not found at ${configPath}; using env/flags/defaults.`);
+  }
+  return { values: config, sources, warnings };
+}
+function maskSecret(value) {
+  if (!value) {
+    return "";
+  }
+  if (value.length <= 4) {
+    return "*".repeat(value.length);
+  }
+  return `${"*".repeat(value.length - 4)}${value.slice(-4)}`;
+}
+function validateResolvedConfig(resolution) {
+  const { values } = resolution;
+  const errors = [];
+  const warnings = [...resolution.warnings];
+  if (!values.baseUrl) {
+    errors.push("Missing required setting: JIRA_BASE_URL (flag/env/file).");
+  }
+  if (!values.projectKey && !values.issueKey) {
+    errors.push("Provide at least one context value: JIRA_PROJECT_KEY or JIRA_ISSUE_KEY.");
+  }
+  if (values.authMode === "api-token") {
+    if (!values.jiraEmail) {
+      errors.push("Auth mode api-token requires JIRA_EMAIL.");
+    }
+    if (!values.jiraApiToken) {
+      errors.push("Auth mode api-token requires JIRA_API_TOKEN.");
+    }
+  } else {
+    if (values.jiraApiToken || values.jiraEmail) {
+      warnings.push("JIRA_EMAIL/JIRA_API_TOKEN were provided but auth mode is 'none'.");
+    }
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function validateCliConfigResolution(resolution) {
+  return validateResolvedConfig(resolution);
+}
+function toDisplayLines(resolution) {
+  const { values, sources } = resolution;
+  return [
+    "Resolved config (secret-safe):",
+    `  baseUrl: ${values.baseUrl || "<unset>"} (${sources.baseUrl})`,
+    `  projectKey: ${values.projectKey || "<unset>"} (${sources.projectKey})`,
+    `  issueKey: ${values.issueKey || "<unset>"} (${sources.issueKey})`,
+    `  authMode: ${values.authMode} (${sources.authMode})`,
+    `  jiraEmail: ${values.jiraEmail || "<unset>"} (${sources.jiraEmail})`,
+    `  jiraApiToken: ${values.jiraApiToken ? maskSecret(values.jiraApiToken) : "<unset>"} (${sources.jiraApiToken})`,
+    `  configPath: ${values.configPath} (${sources.configPath})`
+  ];
+}
+function createConfigHandler(env = process.env, cwd = process.cwd()) {
+  return (request) => {
+    const [subcommand, ...subArgs] = request.args;
+    const resolution = resolveCliConfig(subArgs, env, cwd);
+    const validation = validateCliConfigResolution(resolution);
+    if (subcommand === "show") {
+      return {
+        exitCode: ExitCode.Success,
+        stdout: [...toDisplayLines(resolution), ...validation.warnings.map((line) => `WARN: ${line}`)]
+      };
+    }
+    if (subcommand === "validate") {
+      if (validation.ok) {
+        return {
+          exitCode: ExitCode.Success,
+          stdout: ["Config validation: PASS", ...toDisplayLines(resolution), ...validation.warnings.map((line) => `WARN: ${line}`)]
+        };
+      }
+      return {
+        exitCode: ExitCode.ValidationError,
+        stdout: ["Config validation: FAIL", ...toDisplayLines(resolution)],
+        stderr: validation.errors.map((line) => `ERROR: ${line}`)
+      };
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [`Unsupported config subcommand: ${subcommand}`]
+    };
+  };
+}
+
+// src/autoDetect.ts
+function toPosix(value) {
+  return value.replaceAll("\\", "/");
+}
+function endsWithOneOf(pathValue, suffixes) {
+  return suffixes.some((suffix) => pathValue.endsWith(suffix));
+}
+function countMatches(files, predicate, cap) {
+  let count = 0;
+  for (const filePath of files) {
+    if (!predicate(filePath)) {
+      continue;
+    }
+    count += 1;
+    if (count >= cap) {
+      return cap;
+    }
+  }
+  return count;
+}
+function confidenceForWinner(score) {
+  if (score <= 0) {
+    return "none";
+  }
+  if (score >= 10) {
+    return "high";
+  }
+  if (score >= 5) {
+    return "medium";
+  }
+  return "low";
+}
+function detectFramework(scannedFiles) {
+  const files = scannedFiles.map((filePath) => toPosix(filePath).toLowerCase());
+  const hints = {
+    playwright: [],
+    pytest: [],
+    bdd: []
+  };
+  const hasPlaywrightConfig = files.some(
+    (filePath) => endsWithOneOf(filePath, [
+      "playwright.config.ts",
+      "playwright.config.js",
+      "playwright.config.mjs",
+      "playwright.config.cjs"
+    ])
+  );
+  if (hasPlaywrightConfig) {
+    hints.playwright.push("playwright config");
+  }
+  const playwrightSpecCount = countMatches(
+    files,
+    (filePath) => /(^|\/)(tests?|e2e)\//.test(filePath) && (filePath.includes(".spec.") || filePath.includes(".test.")),
+    3
+  );
+  if (playwrightSpecCount > 0) {
+    hints.playwright.push(`spec/test files x${playwrightSpecCount}`);
+  }
+  const hasPytestConfig = files.some(
+    (filePath) => endsWithOneOf(filePath, ["pytest.ini", "tox.ini"]) || filePath.endsWith("pyproject.toml")
+  );
+  if (hasPytestConfig) {
+    hints.pytest.push("pytest config");
+  }
+  const hasConftest = files.some((filePath) => filePath.endsWith("conftest.py"));
+  if (hasConftest) {
+    hints.pytest.push("conftest.py");
+  }
+  const pytestTestsCount = countMatches(
+    files,
+    (filePath) => filePath.endsWith(".py") && (/(^|\/)test_[^/]+\.py$/.test(filePath) || /(^|\/)[^/]+_test\.py$/.test(filePath)),
+    4
+  );
+  if (pytestTestsCount > 0) {
+    hints.pytest.push(`python test files x${pytestTestsCount}`);
+  }
+  const featureFileCount = countMatches(files, (filePath) => filePath.endsWith(".feature"), 4);
+  if (featureFileCount > 0) {
+    hints.bdd.push(`feature files x${featureFileCount}`);
+  }
+  const hasBehaveConfig = files.some((filePath) => filePath.endsWith("behave.ini"));
+  if (hasBehaveConfig) {
+    hints.bdd.push("behave.ini");
+  }
+  const hasCucumberJson = files.some(
+    (filePath) => filePath.endsWith("cucumber.json") || filePath.endsWith("cucumber-report.json") || filePath.endsWith(".cucumber.json")
+  );
+  if (hasCucumberJson) {
+    hints.bdd.push("cucumber json");
+  }
+  const scores = {
+    playwright: 0,
+    pytest: 0,
+    bdd: 0
+  };
+  if (hasPlaywrightConfig) {
+    scores.playwright += 7;
+  }
+  scores.playwright += playwrightSpecCount;
+  if (hasPytestConfig) {
+    scores.pytest += 6;
+  }
+  if (hasConftest) {
+    scores.pytest += 2;
+  }
+  scores.pytest += pytestTestsCount;
+  scores.bdd += featureFileCount * 2;
+  if (hasBehaveConfig) {
+    scores.bdd += 4;
+  }
+  if (hasCucumberJson) {
+    scores.bdd += 3;
+  }
+  const candidates = Object.entries(scores).map(([framework, score]) => ({ framework, score })).filter((entry) => entry.score > 0).sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    return a.framework.localeCompare(b.framework);
+  });
+  if (candidates.length === 0) {
+    return {
+      mode: "unknown",
+      confidence: "none",
+      scores,
+      candidates: [],
+      hints
+    };
+  }
+  const topScore = candidates[0]?.score ?? 0;
+  const topCandidates = candidates.filter((candidate) => candidate.score === topScore);
+  const secondCandidate = candidates[1];
+  const nearTie = typeof secondCandidate?.score === "number" && topScore > 0 && topScore - secondCandidate.score <= 1;
+  if (topCandidates.length > 1 || nearTie) {
+    return {
+      mode: "ambiguous",
+      confidence: "low",
+      scores,
+      candidates,
+      hints
+    };
+  }
+  const winner = candidates[0]?.framework ?? "bdd";
+  return {
+    mode: winner,
+    confidence: confidenceForWinner(topScore),
+    scores,
+    candidates,
+    hints
+  };
+}
+
+// src/autoDiagnostics.ts
+function toDiagnosticJsonValue(diagnostic) {
+  return {
+    code: diagnostic.code,
+    category: diagnostic.category,
+    level: diagnostic.level,
+    message: diagnostic.message,
+    suggestion: diagnostic.suggestion
+  };
+}
+function formatDiagnosticLine(diagnostic) {
+  return `[${diagnostic.code}] ${diagnostic.message} Suggestion: ${diagnostic.suggestion}`;
+}
+function sortDiagnostics(input) {
+  return [...input].sort((left, right) => {
+    if (left.level !== right.level) {
+      return left.level.localeCompare(right.level);
+    }
+    if (left.category !== right.category) {
+      return left.category.localeCompare(right.category);
+    }
+    if (left.code !== right.code) {
+      return left.code.localeCompare(right.code);
+    }
+    return left.message.localeCompare(right.message);
+  });
+}
+function diagnosticCatalog(input) {
+  const diagnostics = [];
+  if (!input.hasEndpoint) {
+    diagnostics.push({
+      code: "CONFIG_MISSING_ENDPOINT",
+      category: "config",
+      level: "warning",
+      message: "TESTOPS_FORGE_ENDPOINT is not configured.",
+      suggestion: "Set TESTOPS_FORGE_ENDPOINT to enable real upload mode."
+    });
+  }
+  if (!input.hasAuth) {
+    diagnostics.push({
+      code: "CONFIG_MISSING_AUTH",
+      category: "config",
+      level: "warning",
+      message: "TESTOPS_FORGE_AUTH_TOKEN is not configured.",
+      suggestion: "Set TESTOPS_FORGE_AUTH_TOKEN for authenticated upload mode."
+    });
+  }
+  if (input.artifactCount === 0) {
+    diagnostics.push({
+      code: "DISCOVERY_NO_ARTIFACTS",
+      category: "discovery",
+      level: "warning",
+      message: "No JUnit/Cucumber artifacts were discovered.",
+      suggestion: "Generate test result files or widen include patterns before execution."
+    });
+  }
+  if (input.detectionMode === "ambiguous") {
+    diagnostics.push({
+      code: "MAPPING_FRAMEWORK_AMBIGUOUS",
+      category: "mapping",
+      level: "warning",
+      message: "Multiple framework hints were detected with similar confidence.",
+      suggestion: "Use include/exclude options to narrow repository scope."
+    });
+  }
+  if (input.detectionMode === "unknown") {
+    diagnostics.push({
+      code: "MAPPING_FRAMEWORK_UNKNOWN",
+      category: "mapping",
+      level: "warning",
+      message: "No supported framework hints were detected.",
+      suggestion: "Verify repository layout or specify a narrower root path."
+    });
+  }
+  if (!input.dryRun) {
+    diagnostics.push({
+      code: "UPLOAD_EXECUTION_MODE_ACTIVE",
+      category: "upload",
+      level: "warning",
+      message: "Execution mode is active.",
+      suggestion: "Use --dry-run for preview-only validation if needed."
+    });
+  }
+  return sortDiagnostics(diagnostics);
+}
+function diagMappingBlocked() {
+  return {
+    code: "MAPPING_UNCERTAIN_BLOCKED",
+    category: "mapping",
+    level: "error",
+    message: "Execution blocked by uncertain mapping.",
+    suggestion: "Run --dry-run to inspect unmatched entities or pass --force to override."
+  };
+}
+function diagMissingProjectContext() {
+  return {
+    code: "CONFIG_MISSING_PROJECT_CONTEXT",
+    category: "config",
+    level: "error",
+    message: "Missing project context for execution mode.",
+    suggestion: "Set JIRA_PROJECT_KEY or pass --project-key."
+  };
+}
+function diagUploadFeatureFailure(featurePath, reason) {
+  return {
+    code: "UPLOAD_FEATURE_FAILED",
+    category: "upload",
+    level: "error",
+    message: `Feature upload failed for '${featurePath}': ${reason}`,
+    suggestion: "Check feature payload validity and Forge resolver logs."
+  };
+}
+function diagUploadRunFailure(source, scenario, reason) {
+  return {
+    code: "UPLOAD_RUN_FAILED",
+    category: "upload",
+    level: "error",
+    message: `Run upload failed for '${source}' scenario '${scenario}': ${reason}`,
+    suggestion: "Check run payload shape and retry after fixing failed steps."
+  };
+}
+function diagSkippedArtifact(pathValue, reason) {
+  return {
+    code: "DISCOVERY_ARTIFACT_SKIPPED",
+    category: "discovery",
+    level: "warning",
+    message: `Artifact skipped '${pathValue}': ${reason}`,
+    suggestion: "Use supported artifact formats or proceed with BDD/cucumber runs."
+  };
+}
+function diagExecutionNoWork() {
+  return {
+    code: "UPLOAD_NO_WORK_EXECUTED",
+    category: "upload",
+    level: "error",
+    message: "Execution completed without uploading any features or runs.",
+    suggestion: "Verify discovered features/artifacts and adjust include/exclude filters."
+  };
+}
+
+// src/autoDiscover.ts
+import path2 from "node:path";
+var RESULT_FOLDER_NAMES = /* @__PURE__ */ new Set([
+  "results",
+  "result",
+  "reports",
+  "report",
+  "test-results",
+  "allure-results",
+  "surefire-reports",
+  "failsafe-reports"
+]);
+function toPosix2(value) {
+  return value.split(path2.sep).join("/");
+}
+function isJUnitXmlArtifact(filePath) {
+  const normalized = toPosix2(filePath);
+  const lower = normalized.toLowerCase();
+  if (!lower.endsWith(".xml")) {
+    return false;
+  }
+  const fileName = lower.split("/").at(-1) ?? "";
+  if (fileName.startsWith("junit") || fileName.startsWith("test-") || fileName.startsWith("testsuite")) {
+    return true;
+  }
+  return lower.includes("/surefire-reports/") || lower.includes("/failsafe-reports/") || lower.includes("/junit/") || lower.includes("/test-results/");
+}
+function isCucumberJsonArtifact(filePath) {
+  const normalized = toPosix2(filePath);
+  const lower = normalized.toLowerCase();
+  if (!lower.endsWith(".json")) {
+    return false;
+  }
+  const fileName = lower.split("/").at(-1) ?? "";
+  if (fileName === "cucumber.json" || fileName === "cucumber-report.json" || fileName.endsWith(".cucumber.json")) {
+    return true;
+  }
+  return lower.includes("/cucumber/") || lower.includes("/cucumber-reports/");
+}
+function extractResultFolders(files) {
+  const folderSet = /* @__PURE__ */ new Set();
+  for (const inputPath of files) {
+    const normalized = toPosix2(inputPath);
+    const segments = normalized.split("/");
+    if (segments.length < 2) {
+      continue;
+    }
+    for (let index = 0; index < segments.length - 1; index += 1) {
+      const segment = segments[index];
+      if (!RESULT_FOLDER_NAMES.has(segment.toLowerCase())) {
+        continue;
+      }
+      folderSet.add(segments.slice(0, index + 1).join("/"));
+    }
+  }
+  return [...folderSet].sort((a, b) => a.localeCompare(b));
+}
+function discoverArtifacts(scannedFiles) {
+  const discovered = [];
+  for (const filePath of scannedFiles) {
+    if (isJUnitXmlArtifact(filePath)) {
+      discovered.push({ kind: "junit-xml", path: filePath });
+    }
+    if (isCucumberJsonArtifact(filePath)) {
+      discovered.push({ kind: "cucumber-json", path: filePath });
+    }
+  }
+  const deduped = [...new Map(discovered.map((entry) => [`${entry.kind}:${entry.path}`, entry])).values()].sort(
+    (left, right) => {
+      if (left.path !== right.path) {
+        return left.path.localeCompare(right.path);
+      }
+      return left.kind.localeCompare(right.kind);
+    }
+  );
+  const junitXml = deduped.filter((entry) => entry.kind === "junit-xml").length;
+  const cucumberJson = deduped.filter((entry) => entry.kind === "cucumber-json").length;
+  const resultFolders = extractResultFolders(scannedFiles);
+  return {
+    artifacts: deduped,
+    resultFolders,
+    counts: {
+      junitXml,
+      cucumberJson,
+      total: deduped.length
+    }
+  };
+}
+
+// src/autoFeatureDiscovery.ts
+function normalizePath(pathValue) {
+  return pathValue.replaceAll("\\", "/");
+}
+function discoverFeatureFiles(scannedFiles) {
+  const featurePaths = [...new Set(
+    scannedFiles.map((filePath) => normalizePath(filePath)).filter((filePath) => filePath.toLowerCase().endsWith(".feature"))
+  )].sort((a, b) => a.localeCompare(b));
+  return {
+    total: featurePaths.length,
+    paths: featurePaths,
+    sample: featurePaths.slice(0, 10)
+  };
+}
+
+// src/autoMapping.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import path3 from "node:path";
+var ISSUE_KEY_REGEX = /\b[A-Z][A-Z0-9]+-\d+\b/g;
+function normalizeName(value) {
+  return value.trim().toLowerCase();
+}
+function extractIssueKeysFromText(text) {
+  const found = text.match(ISSUE_KEY_REGEX) ?? [];
+  return [...new Set(found)].sort((a, b) => a.localeCompare(b));
+}
+function parseFeatureFile(featureAbsolutePath) {
+  if (!existsSync2(featureAbsolutePath)) {
+    return { names: [], issueKeys: [] };
+  }
+  const raw = readFileSync2(featureAbsolutePath, "utf8");
+  const lines = raw.split(/\r?\n/);
+  const names = /* @__PURE__ */ new Set();
+  const issueKeys = new Set(extractIssueKeysFromText(raw));
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const featureMatch = /^feature:\s*(.+)$/i.exec(trimmed);
+    if (featureMatch?.[1]) {
+      names.add(featureMatch[1].trim());
+    }
+    const scenarioMatch = /^scenario(?: outline)?:\s*(.+)$/i.exec(trimmed);
+    if (scenarioMatch?.[1]) {
+      names.add(scenarioMatch[1].trim());
+    }
+    for (const issueKey of extractIssueKeysFromText(trimmed)) {
+      issueKeys.add(issueKey);
+    }
+  }
+  return {
+    names: [...names].sort((a, b) => a.localeCompare(b)),
+    issueKeys: [...issueKeys].sort((a, b) => a.localeCompare(b))
+  };
+}
+function collectRemoteSnapshot(input) {
+  if (!input) {
+    return { names: [], issueKeys: [] };
+  }
+  const names = /* @__PURE__ */ new Set();
+  const issueKeys = /* @__PURE__ */ new Set();
+  for (const testCase of input.testCases) {
+    names.add(testCase.key);
+    names.add(testCase.title);
+    for (const linkedIssueKey of testCase.linkedIssueKeys ?? []) {
+      issueKeys.add(linkedIssueKey);
+    }
+  }
+  for (const feature of input.bddArtifacts.features) {
+    names.add(feature.payload.name);
+    for (const linkedIssueKey of feature.linkedIssueKeys) {
+      issueKeys.add(linkedIssueKey);
+    }
+  }
+  for (const run of input.bddArtifacts.runs) {
+    names.add(run.payload.featureName);
+    names.add(run.payload.scenarioName);
+    for (const linkedIssueKey of run.linkedIssueKeys) {
+      issueKeys.add(linkedIssueKey);
+    }
+  }
+  return {
+    names: [...names].sort((a, b) => a.localeCompare(b)),
+    issueKeys: [...issueKeys].sort((a, b) => a.localeCompare(b))
+  };
+}
+function buildMappingPreview(input) {
+  const localNamesSet = /* @__PURE__ */ new Set();
+  const issueCandidatesSet = /* @__PURE__ */ new Set();
+  for (const featurePath of input.featurePaths) {
+    const absolutePath = path3.join(input.rootPath, featurePath);
+    const parsed = parseFeatureFile(absolutePath);
+    for (const name of parsed.names) {
+      localNamesSet.add(name);
+    }
+    for (const issueKey of parsed.issueKeys) {
+      issueCandidatesSet.add(issueKey);
+    }
+  }
+  const localNames = [...localNamesSet].sort((a, b) => a.localeCompare(b));
+  const issueKeyCandidates = [...issueCandidatesSet].sort((a, b) => a.localeCompare(b));
+  const remote = collectRemoteSnapshot(input.remoteSnapshot);
+  const remoteNameSet = new Set(remote.names.map((name) => normalizeName(name)));
+  const remoteIssueSet = new Set(remote.issueKeys);
+  if (input.contextIssueKey?.trim()) {
+    remoteIssueSet.add(input.contextIssueKey.trim());
+  }
+  const exactNameMatched = localNames.filter((name) => remoteNameSet.has(normalizeName(name))).sort((a, b) => a.localeCompare(b));
+  const unmatchedNames = localNames.filter((name) => !remoteNameSet.has(normalizeName(name))).sort((a, b) => a.localeCompare(b));
+  const issueKeyMatched = issueKeyCandidates.filter((issueKey) => remoteIssueSet.has(issueKey)).sort((a, b) => a.localeCompare(b));
+  const issueKeyUnmatched = issueKeyCandidates.filter((issueKey) => !remoteIssueSet.has(issueKey)).sort((a, b) => a.localeCompare(b));
+  const diagnostics = [];
+  if (localNames.length === 0) {
+    diagnostics.push("No feature/scenario names extracted for mapping preview.");
+  }
+  if (!input.remoteSnapshot) {
+    diagnostics.push("Remote snapshot unavailable; using estimate-only mapping.");
+  }
+  if (issueKeyCandidates.length === 0) {
+    diagnostics.push("No Jira issue-key candidates found in local feature text.");
+  }
+  if (unmatchedNames.length > 0) {
+    diagnostics.push(`Unmatched names: ${unmatchedNames.length}.`);
+  }
+  if (issueKeyUnmatched.length > 0) {
+    diagnostics.push(`Unmatched issue keys: ${issueKeyUnmatched.join(", ")}.`);
+  }
+  return {
+    mode: input.remoteSnapshot ? "contract-assisted" : "estimate-only",
+    issueKeyCandidates,
+    issueKeyMatched,
+    issueKeyUnmatched,
+    exactNameMatched,
+    unmatchedNames,
+    diagnostics
+  };
+}
+
+// src/autoScanner.ts
+import { readdirSync } from "node:fs";
+import path4 from "node:path";
+var DEFAULT_MAX_DEPTH = 5;
+var DEFAULT_EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".cache",
+  ".git",
+  ".next",
+  ".pnpm",
+  ".yarn",
+  "allure-report",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+function normalizeRelativePath(value) {
+  return value.split(path4.sep).join("/");
+}
+function normalizePatterns(values) {
+  if (!values) {
+    return [];
+  }
+  return values.map((value) => normalizeRelativePath(value.trim())).filter(Boolean).sort((a, b) => a.localeCompare(b));
+}
+function safeMaxDepth(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) {
+    return DEFAULT_MAX_DEPTH;
+  }
+  if (input < 0) {
+    return 0;
+  }
+  return Math.floor(input);
+}
+function matchesAnyPattern(relativePath, patterns) {
+  const normalized = normalizeRelativePath(relativePath);
+  if (patterns.length === 0) {
+    return false;
+  }
+  return patterns.some((pattern) => {
+    if (normalized === pattern) {
+      return true;
+    }
+    if (normalized.startsWith(`${pattern}/`)) {
+      return true;
+    }
+    if (normalized.includes(pattern)) {
+      return true;
+    }
+    return false;
+  });
+}
+function isIncluded(relativePath, includePatterns) {
+  if (includePatterns.length === 0) {
+    return true;
+  }
+  return matchesAnyPattern(relativePath, includePatterns);
+}
+function isExcluded(relativePath, excludePatterns) {
+  return matchesAnyPattern(relativePath, excludePatterns);
+}
+function shouldSkipDefaultDirectory(directoryName, relativePath, includePatterns) {
+  if (!DEFAULT_EXCLUDED_DIRECTORIES.has(directoryName)) {
+    return false;
+  }
+  return !matchesAnyPattern(relativePath, includePatterns);
+}
+function scanProjectFiles(options) {
+  const includePatterns = normalizePatterns(options.includePatterns);
+  const excludePatterns = normalizePatterns(options.excludePatterns);
+  const maxDepth = safeMaxDepth(options.maxDepth);
+  const rootPath = path4.resolve(options.rootPath);
+  const scannedFiles = [];
+  const visit = (absoluteDirectory, depth) => {
+    if (depth > maxDepth) {
+      return;
+    }
+    const entries = readdirSync(absoluteDirectory, { withFileTypes: true }).slice().sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const absoluteEntryPath = path4.join(absoluteDirectory, entry.name);
+      const relativeEntryPath = normalizeRelativePath(path4.relative(rootPath, absoluteEntryPath));
+      if (!relativeEntryPath) {
+        continue;
+      }
+      if (isExcluded(relativeEntryPath, excludePatterns)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (shouldSkipDefaultDirectory(entry.name, relativeEntryPath, includePatterns)) {
+          continue;
+        }
+        visit(absoluteEntryPath, depth + 1);
+        continue;
+      }
+      if (!isIncluded(relativeEntryPath, includePatterns)) {
+        continue;
+      }
+      scannedFiles.push(relativeEntryPath);
+    }
+  };
+  visit(rootPath, 0);
+  scannedFiles.sort((a, b) => a.localeCompare(b));
+  return {
+    rootPath,
+    maxDepth,
+    scannedFiles
+  };
+}
+
+// src/auto.ts
+var DETERMINISTIC_STEPS = [
+  "detect",
+  "discover",
+  "map-preview",
+  "upload"
+];
+function parseArgs(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const valuedFlags = /* @__PURE__ */ new Set([
+    "--root",
+    "--include",
+    "--exclude",
+    "--output",
+    "--max-depth",
+    "--config",
+    "--base-url",
+    "--project-key",
+    "--issue-key",
+    "--auth-mode",
+    "--jira-email",
+    "--jira-api-token"
+  ]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--dry-run", "--json", "--force"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!valuedFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+var CONFIG_FLAGS = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function pickConfigArgs(parsed) {
+  const configArgs = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (!CONFIG_FLAGS.has(flag)) {
+      continue;
+    }
+    configArgs.push(flag, value);
+  }
+  return configArgs;
+}
+function normalizeListFlag(value) {
+  if (!value.trim()) {
+    return [];
+  }
+  return value.split(",").map((part) => part.trim()).filter(Boolean).sort((a, b) => a.localeCompare(b));
+}
+function resolveRoot(rootFlag, cwd) {
+  if (!rootFlag.trim()) {
+    return cwd;
+  }
+  return path5.resolve(cwd, rootFlag);
+}
+function countScenariosInFeatureFile(featurePath) {
+  const lines = readFileSync3(featurePath, "utf8").split(/\r?\n/).map((line) => line.trim().toLowerCase());
+  let count = 0;
+  for (const line of lines) {
+    if (line.startsWith("scenario:") || line.startsWith("scenario outline:")) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function buildScenarioStats(rootPath, featurePaths) {
+  let scenarios = 0;
+  for (const relativePath of featurePaths) {
+    const absolutePath = path5.join(rootPath, relativePath);
+    if (!existsSync3(absolutePath)) {
+      continue;
+    }
+    scenarios += countScenariosInFeatureFile(absolutePath);
+  }
+  return { scenarios };
+}
+function toPrefixBeforeFeatures(featurePath) {
+  const normalized = featurePath.replaceAll("\\", "/");
+  const marker = "/features/";
+  const index = normalized.indexOf(marker);
+  if (index <= 0) {
+    return "";
+  }
+  return normalized.slice(0, index);
+}
+function deriveFeaturePairingHints(featurePaths, artifactPaths) {
+  const hints = /* @__PURE__ */ new Set();
+  for (const featurePath of featurePaths) {
+    const featurePrefix = toPrefixBeforeFeatures(featurePath);
+    if (!featurePrefix) {
+      continue;
+    }
+    for (const artifactPath of artifactPaths) {
+      if (!artifactPath.startsWith(`${featurePrefix}/`)) {
+        continue;
+      }
+      hints.add(`${featurePath} -> ${artifactPath}`);
+    }
+  }
+  return [...hints].sort((a, b) => a.localeCompare(b));
+}
+function deriveFeatureNameFromGherkin(gherkin, fallbackPath) {
+  const lines = gherkin.split(/\r?\n/);
+  for (const line of lines) {
+    const match = /^feature:\s*(.+)$/i.exec(line.trim());
+    if (match?.[1]?.trim()) {
+      return match[1].trim();
+    }
+  }
+  return path5.basename(fallbackPath, path5.extname(fallbackPath));
+}
+function mapStepStatus(status) {
+  const normalized = status.trim().toLowerCase();
+  if (normalized === "passed" || normalized === "pass") {
+    return StepResult.Passed;
+  }
+  if (normalized === "failed" || normalized === "fail") {
+    return StepResult.Failed;
+  }
+  if (normalized === "skipped" || normalized === "pending" || normalized === "undefined") {
+    return StepResult.Skipped;
+  }
+  return StepResult.Blocked;
+}
+function parseCucumberRunsFromArtifact(rootPath, artifactPath) {
+  const absolutePath = path5.join(rootPath, artifactPath);
+  if (!existsSync3(absolutePath)) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(absolutePath, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  const candidates = [];
+  for (const featureEntry of parsed) {
+    if (!featureEntry || typeof featureEntry !== "object") {
+      continue;
+    }
+    const feature = featureEntry;
+    const featureName = typeof feature.name === "string" ? feature.name.trim() : "";
+    const elements = Array.isArray(feature.elements) ? feature.elements : Array.isArray(feature.scenarios) ? feature.scenarios : [];
+    for (const elementEntry of elements) {
+      if (!elementEntry || typeof elementEntry !== "object") {
+        continue;
+      }
+      const element = elementEntry;
+      const scenarioName = typeof element.name === "string" ? element.name.trim() : "";
+      const stepEntries = Array.isArray(element.steps) ? element.steps : [];
+      const steps = [];
+      for (const stepEntry of stepEntries) {
+        if (!stepEntry || typeof stepEntry !== "object") {
+          continue;
+        }
+        const step = stepEntry;
+        const stepText = `${typeof step.keyword === "string" ? step.keyword.trim() : ""} ${typeof step.name === "string" ? step.name.trim() : ""}`.trim();
+        if (!stepText) {
+          continue;
+        }
+        const result = step.result && typeof step.result === "object" ? step.result : {};
+        const mapped = mapStepStatus(typeof result.status === "string" ? result.status : "");
+        const errorMessage = typeof result.error_message === "string" ? result.error_message : "";
+        steps.push({
+          step: stepText,
+          result: mapped,
+          error: mapped === StepResult.Failed ? errorMessage || "cucumber step failed" : void 0
+        });
+      }
+      if (!featureName || !scenarioName || steps.length === 0) {
+        continue;
+      }
+      candidates.push({
+        sourcePath: artifactPath,
+        input: {
+          featureName,
+          scenarioName,
+          executedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          steps
+        }
+      });
+    }
+  }
+  return candidates.sort((left, right) => {
+    if (left.sourcePath !== right.sourcePath) {
+      return left.sourcePath.localeCompare(right.sourcePath);
+    }
+    if (left.input.featureName !== right.input.featureName) {
+      return left.input.featureName.localeCompare(right.input.featureName);
+    }
+    return left.input.scenarioName.localeCompare(right.input.scenarioName);
+  });
+}
+function normalizeExecutionError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "unknown execution error";
+}
+async function executeUploadFlow(input) {
+  if ((input.mappingPreview.issueKeyUnmatched.length > 0 || input.mappingPreview.unmatchedNames.length > 0) && !input.force) {
+    const blockingDiagnostic = diagMappingBlocked();
+    return {
+      executed: false,
+      blockedReason: blockingDiagnostic.message,
+      featureSuccess: 0,
+      featureFailed: 0,
+      runSuccess: 0,
+      runFailed: 0,
+      skippedArtifacts: [],
+      errors: [],
+      diagnostics: [blockingDiagnostic]
+    };
+  }
+  let featureSuccess = 0;
+  let featureFailed = 0;
+  let runSuccess = 0;
+  let runFailed = 0;
+  const skippedArtifacts = [];
+  const errors = [];
+  const diagnostics = [];
+  const orderedFeatures = [...input.featurePaths].sort((a, b) => a.localeCompare(b));
+  for (const featurePath of orderedFeatures) {
+    const absolutePath = path5.join(input.rootPath, featurePath);
+    if (!existsSync3(absolutePath)) {
+      featureFailed += 1;
+      const diagnostic = diagUploadFeatureFailure(featurePath, "missing feature file");
+      errors.push(diagnostic.message);
+      diagnostics.push(diagnostic);
+      continue;
+    }
+    const gherkin = readFileSync3(absolutePath, "utf8");
+    const name = deriveFeatureNameFromGherkin(gherkin, featurePath);
+    const payload = {
+      context: {
+        projectKey: input.projectKey,
+        issueKey: input.issueKey || void 0
+      },
+      input: {
+        name,
+        gherkin
+      }
+    };
+    try {
+      const response = await input.context.invokeForgeContract("ingestBddFeature", payload);
+      if (response.ok) {
+        featureSuccess += 1;
+      } else {
+        featureFailed += 1;
+        const diagnostic = diagUploadFeatureFailure(featurePath, response.error.code);
+        errors.push(diagnostic.message);
+        diagnostics.push(diagnostic);
+      }
+    } catch (error) {
+      featureFailed += 1;
+      const diagnostic = diagUploadFeatureFailure(featurePath, normalizeExecutionError(error));
+      errors.push(diagnostic.message);
+      diagnostics.push(diagnostic);
+    }
+  }
+  const orderedArtifacts = [...input.artifactList].sort((a, b) => a.path.localeCompare(b.path));
+  for (const artifact of orderedArtifacts) {
+    if (artifact.kind === "cucumber-json") {
+      const runs = parseCucumberRunsFromArtifact(input.rootPath, artifact.path);
+      if (runs.length === 0) {
+        const diagnostic2 = diagSkippedArtifact(artifact.path, "no runnable scenarios");
+        skippedArtifacts.push(diagnostic2.message);
+        diagnostics.push(diagnostic2);
+        continue;
+      }
+      for (const run of runs) {
+        const payload = {
+          context: {
+            projectKey: input.projectKey,
+            issueKey: input.issueKey || void 0
+          },
+          input: run.input
+        };
+        try {
+          const response = await input.context.invokeForgeContract("ingestBddRun", payload);
+          if (response.ok) {
+            runSuccess += 1;
+          } else {
+            runFailed += 1;
+            const diagnostic2 = diagUploadRunFailure(run.sourcePath, run.input.scenarioName, response.error.code);
+            errors.push(diagnostic2.message);
+            diagnostics.push(diagnostic2);
+          }
+        } catch (error) {
+          runFailed += 1;
+          const diagnostic2 = diagUploadRunFailure(
+            run.sourcePath,
+            run.input.scenarioName,
+            normalizeExecutionError(error)
+          );
+          errors.push(diagnostic2.message);
+          diagnostics.push(diagnostic2);
+        }
+      }
+      continue;
+    }
+    if (artifact.kind === "junit-xml") {
+      const diagnostic2 = diagSkippedArtifact(artifact.path, "junit upload not supported in AUTO-8");
+      skippedArtifacts.push(diagnostic2.message);
+      diagnostics.push(diagnostic2);
+      continue;
+    }
+    const diagnostic = diagSkippedArtifact(artifact.path, `unsupported artifact kind: ${artifact.kind}`);
+    skippedArtifacts.push(diagnostic.message);
+    diagnostics.push(diagnostic);
+  }
+  if (featureSuccess + runSuccess === 0) {
+    diagnostics.push(diagExecutionNoWork());
+  }
+  return {
+    executed: true,
+    featureSuccess,
+    featureFailed,
+    runSuccess,
+    runFailed,
+    skippedArtifacts: skippedArtifacts.sort((a, b) => a.localeCompare(b)),
+    errors: errors.sort((a, b) => a.localeCompare(b)),
+    diagnostics: sortDiagnostics(diagnostics)
+  };
+}
+function buildSummary(input) {
+  const scanSample = input.scannedFiles.slice(0, 10);
+  const detection = detectFramework(input.scannedFiles);
+  const discovery = discoverArtifacts(input.scannedFiles);
+  const featureDiscovery = discoverFeatureFiles(input.scannedFiles);
+  const scenarioStats = buildScenarioStats(input.rootPath, featureDiscovery.paths);
+  const candidateSummary = detection.candidates.map((candidate) => ({
+    framework: candidate.framework,
+    score: candidate.score
+  }));
+  const artifactSummary = discovery.artifacts.map((artifact) => ({
+    kind: artifact.kind,
+    path: artifact.path
+  }));
+  const featurePairingHints = deriveFeaturePairingHints(
+    featureDiscovery.paths,
+    artifactSummary.map((artifact) => artifact.path)
+  );
+  const matchSummary = {
+    mode: input.mappingPreview.mode,
+    matched: input.mappingPreview.exactNameMatched.length,
+    unmatched: input.mappingPreview.unmatchedNames.length,
+    issueKeyCandidates: input.mappingPreview.issueKeyCandidates.length,
+    issueKeyMatched: input.mappingPreview.issueKeyMatched.length,
+    issueKeyUnmatched: input.mappingPreview.issueKeyUnmatched.length,
+    note: "Deterministic MVP mapping preview."
+  };
+  const warnings = diagnosticCatalog({
+    dryRun: input.dryRun,
+    detectionMode: detection.mode,
+    artifactCount: discovery.counts.total,
+    hasEndpoint: Boolean(input.env.TESTOPS_FORGE_ENDPOINT?.trim()),
+    hasAuth: Boolean(input.env.TESTOPS_FORGE_AUTH_TOKEN?.trim())
+  });
+  return {
+    action: "auto",
+    mode: input.dryRun ? "dry-run" : "execute",
+    root: input.rootPath,
+    include: input.include,
+    exclude: input.exclude,
+    output: input.output,
+    deterministicOrder: DETERMINISTIC_STEPS,
+    scan: {
+      maxDepth: input.maxDepth,
+      fileCount: input.scannedFiles.length,
+      sample: scanSample
+    },
+    detection: {
+      mode: detection.mode,
+      confidence: detection.confidence,
+      scores: detection.scores,
+      candidates: candidateSummary,
+      hints: detection.hints
+    },
+    discovery: {
+      counts: discovery.counts,
+      artifacts: artifactSummary,
+      resultFolders: discovery.resultFolders,
+      bddFeatures: {
+        total: featureDiscovery.total,
+        sample: featureDiscovery.sample,
+        paths: featureDiscovery.paths,
+        pairingHints: featurePairingHints
+      }
+    },
+    preview: {
+      counts: {
+        testsEstimate: discovery.counts.total,
+        scenarios: scenarioStats.scenarios
+      },
+      matchSummary,
+      mapping: {
+        issueKeyCandidates: input.mappingPreview.issueKeyCandidates,
+        issueKeyMatched: input.mappingPreview.issueKeyMatched,
+        issueKeyUnmatched: input.mappingPreview.issueKeyUnmatched,
+        exactNameMatched: input.mappingPreview.exactNameMatched,
+        unmatchedNames: input.mappingPreview.unmatchedNames,
+        diagnostics: input.mappingPreview.diagnostics
+      },
+      warnings: warnings.map((warning) => toDiagnosticJsonValue(warning))
+    },
+    execution: input.execution ? {
+      executed: input.execution.executed,
+      blockedReason: input.execution.blockedReason ?? "",
+      featureSuccess: input.execution.featureSuccess,
+      featureFailed: input.execution.featureFailed,
+      runSuccess: input.execution.runSuccess,
+      runFailed: input.execution.runFailed,
+      skippedArtifacts: input.execution.skippedArtifacts,
+      errors: input.execution.errors,
+      diagnostics: input.execution.diagnostics.map((diagnostic) => toDiagnosticJsonValue(diagnostic))
+    } : {
+      executed: false,
+      blockedReason: "",
+      featureSuccess: 0,
+      featureFailed: 0,
+      runSuccess: 0,
+      runFailed: 0,
+      skippedArtifacts: [],
+      errors: [],
+      diagnostics: []
+    }
+  };
+}
+function toHumanLines(summary) {
+  const mode = String(summary.mode ?? "dry-run");
+  const root = String(summary.root ?? "");
+  const include = summary.include ?? [];
+  const exclude = summary.exclude ?? [];
+  const output = String(summary.output ?? "plain");
+  const order = summary.deterministicOrder ?? [];
+  const scan = summary.scan ?? {};
+  const detection = summary.detection ?? {};
+  const discovery = summary.discovery ?? {};
+  const preview = summary.preview ?? {};
+  const execution = summary.execution ?? {};
+  const scanCount = typeof scan.fileCount === "number" ? scan.fileCount : 0;
+  const scanDepth = typeof scan.maxDepth === "number" ? scan.maxDepth : 0;
+  const scanSample = (scan.sample ?? []).slice(0, 5);
+  const detectionMode = String(detection.mode ?? "unknown");
+  const detectionConfidence = String(detection.confidence ?? "none");
+  const topCandidates = (detection.candidates ?? []).slice(0, 3).map((candidate) => `${candidate.framework ?? "unknown"}:${candidate.score ?? 0}`);
+  const discoveryCounts = discovery.counts ?? {};
+  const artifactTotal = typeof discoveryCounts.total === "number" ? discoveryCounts.total : 0;
+  const junitTotal = typeof discoveryCounts.junitXml === "number" ? discoveryCounts.junitXml : 0;
+  const cucumberTotal = typeof discoveryCounts.cucumberJson === "number" ? discoveryCounts.cucumberJson : 0;
+  const artifactSample = (discovery.artifacts ?? []).slice(0, 5).map((artifact) => `${artifact.kind ?? "unknown"}:${artifact.path ?? ""}`);
+  const resultFolderSample = (discovery.resultFolders ?? []).slice(0, 5);
+  const bddFeatures = discovery.bddFeatures ?? {};
+  const bddFeatureTotal = typeof bddFeatures.total === "number" ? bddFeatures.total : 0;
+  const bddFeatureSample = (bddFeatures.sample ?? []).slice(0, 5);
+  const pairingHints = (bddFeatures.pairingHints ?? []).slice(0, 3);
+  const previewCounts = preview.counts ?? {};
+  const testsEstimate = typeof previewCounts.testsEstimate === "number" ? previewCounts.testsEstimate : 0;
+  const scenarios = typeof previewCounts.scenarios === "number" ? previewCounts.scenarios : 0;
+  const matchSummary = preview.matchSummary ?? {};
+  const matched = typeof matchSummary.matched === "number" ? matchSummary.matched : 0;
+  const unmatched = typeof matchSummary.unmatched === "number" ? matchSummary.unmatched : 0;
+  const issueKeyCandidates = typeof matchSummary.issueKeyCandidates === "number" ? matchSummary.issueKeyCandidates : 0;
+  const issueKeyMatched = typeof matchSummary.issueKeyMatched === "number" ? matchSummary.issueKeyMatched : 0;
+  const issueKeyUnmatched = typeof matchSummary.issueKeyUnmatched === "number" ? matchSummary.issueKeyUnmatched : 0;
+  const matchMode = String(matchSummary.mode ?? "estimate-only");
+  const mapping = preview.mapping ?? {};
+  const unmatchedNameSample = (mapping.unmatchedNames ?? []).slice(0, 3);
+  const diagnosticSample = (mapping.diagnostics ?? []).slice(0, 3);
+  const warningLines = (preview.warnings ?? []).slice(0, 5).map((warning) => {
+    return formatDiagnosticLine({
+      code: warning.code ?? "WARN",
+      category: warning.category ?? "contract",
+      level: warning.level ?? "warning",
+      message: warning.message ?? "",
+      suggestion: warning.suggestion ?? ""
+    });
+  });
+  const executionDiagnosticLines = (execution.diagnostics ?? []).slice(0, 5).map(
+    (diagnostic) => formatDiagnosticLine({
+      code: diagnostic.code ?? "EXEC",
+      category: diagnostic.category ?? "upload",
+      level: diagnostic.level ?? "error",
+      message: diagnostic.message ?? "",
+      suggestion: diagnostic.suggestion ?? ""
+    })
+  );
+  const executionBlockedReason = String(execution.blockedReason ?? "");
+  const executionSkipped = (execution.skippedArtifacts ?? []).slice(0, 3);
+  const executionErrors = (execution.errors ?? []).slice(0, 3);
+  const executionFeatureSuccess = typeof execution.featureSuccess === "number" ? execution.featureSuccess : 0;
+  const executionFeatureFailed = typeof execution.featureFailed === "number" ? execution.featureFailed : 0;
+  const executionRunSuccess = typeof execution.runSuccess === "number" ? execution.runSuccess : 0;
+  const executionRunFailed = typeof execution.runFailed === "number" ? execution.runFailed : 0;
+  const executionAttempted = Boolean(execution.executed);
+  return [
+    `Auto mode: ${mode.toUpperCase()}`,
+    `Root: ${root}`,
+    `Include: ${include.length > 0 ? include.join(", ") : "<none>"}`,
+    `Exclude: ${exclude.length > 0 ? exclude.join(", ") : "<none>"}`,
+    `Max depth: ${scanDepth}`,
+    `Output: ${output}`,
+    `Scanned files: ${scanCount}`,
+    `Scanned sample: ${scanSample.length > 0 ? scanSample.join(", ") : "<none>"}`,
+    `Framework detection: ${detectionMode} (confidence: ${detectionConfidence})`,
+    `Detection candidates: ${topCandidates.length > 0 ? topCandidates.join(", ") : "<none>"}`,
+    `Discovered artifacts: ${artifactTotal} (junit=${junitTotal}, cucumber=${cucumberTotal})`,
+    `Artifact sample: ${artifactSample.length > 0 ? artifactSample.join(", ") : "<none>"}`,
+    `Result folders: ${resultFolderSample.length > 0 ? resultFolderSample.join(", ") : "<none>"}`,
+    `BDD feature files: ${bddFeatureTotal}`,
+    `BDD feature sample: ${bddFeatureSample.length > 0 ? bddFeatureSample.join(", ") : "<none>"}`,
+    `BDD pairing hints: ${pairingHints.length > 0 ? pairingHints.join(", ") : "<none>"}`,
+    `Preview counts: tests=${testsEstimate}, scenarios=${scenarios}`,
+    `Match summary (${matchMode}): matched=${matched}, unmatched=${unmatched}`,
+    `Issue-key summary: candidates=${issueKeyCandidates}, matched=${issueKeyMatched}, unmatched=${issueKeyUnmatched}`,
+    `Unmatched names sample: ${unmatchedNameSample.length > 0 ? unmatchedNameSample.join(", ") : "<none>"}`,
+    `Mapping diagnostics: ${diagnosticSample.length > 0 ? diagnosticSample.join(" | ") : "<none>"}`,
+    `Warnings: ${warningLines.length > 0 ? warningLines.join("; ") : "<none>"}`,
+    `Execution attempted: ${executionAttempted ? "yes" : "no"}`,
+    `Execution summary: features ok=${executionFeatureSuccess}, features failed=${executionFeatureFailed}, runs ok=${executionRunSuccess}, runs failed=${executionRunFailed}`,
+    `Execution skipped artifacts: ${executionSkipped.length > 0 ? executionSkipped.join(", ") : "<none>"}`,
+    `Execution errors: ${executionErrors.length > 0 ? executionErrors.join(" | ") : executionBlockedReason || "<none>"}`,
+    `Execution diagnostics: ${executionDiagnosticLines.length > 0 ? executionDiagnosticLines.join(" | ") : "<none>"}`,
+    `Deterministic flow: ${order.join(" -> ")}`,
+    mode === "dry-run" ? "Dry-run only: no uploads or mutations are performed." : "Execution mode contract only: upload stage is delegated to Forge wrappers."
+  ];
+}
+function buildAutoContractHelp() {
+  return [
+    "auto command",
+    "",
+    "Usage:",
+    "  testops auto [--dry-run] [--force] [--root <path>] [--include <csv>] [--exclude <csv>] [--max-depth <n>] [--output plain|json]",
+    "",
+    "Deterministic execution order:",
+    "  detect -> discover -> map-preview -> upload",
+    "  detection output includes confidence and explicit ambiguous/unknown states",
+    "  dry-run preview includes counts, match estimate, warnings, and suggestions",
+    "",
+    "Thin-client boundary:",
+    "  CLI orchestrates only and must delegate domain decisions/uploads to Forge contracts."
+  ].join("\n");
+}
+function createAutoHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const parsed = parseArgs(request.args);
+    const dryRun = parsed.boolFlags.has("--dry-run");
+    const force = parsed.boolFlags.has("--force");
+    const useJson = parsed.boolFlags.has("--json") || parsed.flags["--output"] === "json";
+    const output = parsed.flags["--output"]?.trim() || (useJson ? "json" : "plain");
+    const rootPath = resolveRoot(parsed.flags["--root"] ?? "", cwd);
+    const maxDepthValue = parsed.flags["--max-depth"]?.trim();
+    const include = normalizeListFlag(parsed.flags["--include"] ?? "");
+    const exclude = normalizeListFlag(parsed.flags["--exclude"] ?? "");
+    const configResolution = resolveCliConfig(pickConfigArgs(parsed), env, cwd);
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (output !== "plain" && output !== "json") {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: ["ERROR: --output must be either 'plain' or 'json'."]
+      };
+    }
+    if (!existsSync3(rootPath)) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: [`ERROR: Root path does not exist: ${rootPath}`]
+      };
+    }
+    if (maxDepthValue && !/^\d+$/.test(maxDepthValue)) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: ["ERROR: --max-depth must be a non-negative integer."]
+      };
+    }
+    const maxDepth = maxDepthValue ? Number.parseInt(maxDepthValue, 10) : 5;
+    const scanResult = scanProjectFiles({
+      rootPath,
+      includePatterns: include,
+      excludePatterns: exclude,
+      maxDepth
+    });
+    let remoteSnapshot;
+    const projectKey = configResolution.values.projectKey;
+    const issueKey = configResolution.values.issueKey || void 0;
+    if (projectKey && env.TESTOPS_FORGE_ENDPOINT?.trim()) {
+      try {
+        const [testCasesResult, bddArtifactsResult] = await Promise.all([
+          context.invokeForgeContract("listTestCases", {
+            context: { projectKey, issueKey }
+          }),
+          context.invokeForgeContract("listBddArtifacts", {
+            context: { projectKey, issueKey }
+          })
+        ]);
+        if (testCasesResult.ok && bddArtifactsResult.ok) {
+          remoteSnapshot = {
+            testCases: testCasesResult.data,
+            bddArtifacts: bddArtifactsResult.data
+          };
+        }
+      } catch {
+      }
+    }
+    const featureDiscoveryForMapping = discoverFeatureFiles(scanResult.scannedFiles);
+    const discoveredArtifacts = discoverArtifacts(scanResult.scannedFiles);
+    const mappingPreview = buildMappingPreview({
+      rootPath,
+      featurePaths: featureDiscoveryForMapping.paths,
+      contextIssueKey: issueKey,
+      remoteSnapshot
+    });
+    let execution;
+    let exitCode = ExitCode.Success;
+    if (!dryRun) {
+      if (!projectKey) {
+        const diagnostic = diagMissingProjectContext();
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: [
+            `ERROR: ${diagnostic.code}: ${diagnostic.message}`,
+            `SUGGESTION: ${diagnostic.suggestion}`
+          ]
+        };
+      }
+      execution = await executeUploadFlow({
+        rootPath,
+        projectKey,
+        issueKey,
+        featurePaths: featureDiscoveryForMapping.paths,
+        artifactList: discoveredArtifacts.artifacts,
+        mappingPreview,
+        force,
+        context
+      });
+      if (!execution.executed && execution.blockedReason) {
+        exitCode = ExitCode.ValidationError;
+      } else if (execution.featureFailed + execution.runFailed > 0) {
+        exitCode = ExitCode.RemoteError;
+      } else if (execution.featureSuccess + execution.runSuccess === 0) {
+        exitCode = ExitCode.ValidationError;
+      }
+    }
+    const summary = buildSummary({
+      rootPath,
+      dryRun,
+      include,
+      exclude,
+      output,
+      maxDepth: scanResult.maxDepth,
+      scannedFiles: scanResult.scannedFiles,
+      env,
+      mappingPreview,
+      execution
+    });
+    if (output === "json" || useJson) {
+      return {
+        exitCode,
+        stdout: toJsonLine(summary)
+      };
+    }
+    return {
+      exitCode,
+      stdout: toHumanLines(summary)
+    };
+  };
+}
+
+// src/forgeClient.ts
+var ForgeClientError = class extends Error {
+  code;
+  status;
+  retryable;
+  constructor(input) {
+    super(input.message);
+    this.name = "ForgeClientError";
+    this.code = input.code;
+    this.status = input.status;
+    this.retryable = Boolean(input.retryable);
+  }
+};
+function isObject(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function isServiceError(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const code = value.code;
+  const message = value.message;
+  return typeof code === "string" && typeof message === "string";
+}
+function normalizeServiceError(error) {
+  return new ForgeClientError({
+    code: error.code,
+    message: error.message,
+    retryable: false
+  });
+}
+function normalizeUnknownResponseError(status, message) {
+  return new ForgeClientError({
+    code: "HTTP_ERROR",
+    status,
+    message,
+    retryable: status === 429 || status >= 500
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeEndpoint(endpoint) {
+  return endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+}
+function shouldRetry(error, attempt, maxRetries) {
+  if (attempt >= maxRetries) {
+    return false;
+  }
+  return error.retryable;
+}
+var ForgeApiClient = class {
+  endpoint;
+  authToken;
+  timeoutMs;
+  maxRetries;
+  retryDelayMs;
+  fetchImpl;
+  constructor(options) {
+    this.endpoint = normalizeEndpoint(options.endpoint);
+    this.authToken = options.authToken ?? "";
+    this.timeoutMs = options.timeoutMs ?? 5e3;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.retryDelayMs = options.retryDelayMs ?? 250;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async invoke(contract, payload) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.invokeOnce(contract, payload);
+      } catch (error) {
+        const normalized = this.normalizeThrownError(error);
+        if (!shouldRetry(normalized, attempt, this.maxRetries)) {
+          throw normalized;
+        }
+        attempt += 1;
+        const backoff = this.retryDelayMs * attempt;
+        await delay(backoff);
+      }
+    }
+  }
+  async invokeOnce(contract, payload) {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchImpl(this.endpoint, {
+        method: "POST",
+        signal: abortController.signal,
+        headers: {
+          "content-type": "application/json",
+          ...this.authToken ? { authorization: `Bearer ${this.authToken}` } : {}
+        },
+        body: JSON.stringify({
+          contract,
+          payload
+        })
+      });
+      const text = await response.text();
+      let parsed = {};
+      if (text) {
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          throw new ForgeClientError({
+            code: "INVALID_RESPONSE_ERROR",
+            message: "Forge endpoint returned invalid JSON payload.",
+            status: response.status,
+            retryable: false
+          });
+        }
+      }
+      if (!response.ok) {
+        if (isObject(parsed) && "error" in parsed && isServiceError(parsed.error)) {
+          const errorShape = parsed.error;
+          throw normalizeServiceError(errorShape);
+        }
+        throw normalizeUnknownResponseError(
+          response.status,
+          `Forge endpoint request failed with HTTP ${response.status}.`
+        );
+      }
+      if (isObject(parsed) && "ok" in parsed && parsed.ok === false && "error" in parsed && isServiceError(parsed.error)) {
+        throw normalizeServiceError(parsed.error);
+      }
+      return parsed;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  normalizeThrownError(error) {
+    if (error instanceof ForgeClientError) {
+      return error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      return new ForgeClientError({
+        code: "TIMEOUT_ERROR",
+        message: `Forge endpoint timed out after ${this.timeoutMs}ms.`,
+        retryable: true
+      });
+    }
+    return new ForgeClientError({
+      code: "NETWORK_ERROR",
+      message: error instanceof Error ? error.message : "Unknown network error while calling Forge endpoint.",
+      retryable: true
+    });
+  }
+};
+function createForgeApiClient(options) {
+  return new ForgeApiClient(options);
+}
+
+// src/bdd.ts
+var CONFIG_FLAGS2 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs2(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--id", ...CONFIG_FLAGS2]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!supportedValueFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    index += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs2(parsed) {
+  const args = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS2.has(flag)) {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeError(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown bdd command error.";
+}
+function toJsonScenario(scenario) {
+  return {
+    id: scenario.id,
+    featureId: scenario.featureId,
+    featureName: scenario.featureName,
+    name: scenario.name,
+    tags: [...scenario.tags],
+    linkedIssueKeys: [...scenario.linkedIssueKeys],
+    steps: scenario.steps.map((step) => ({
+      keyword: step.keyword,
+      text: step.text
+    })),
+    createdAt: scenario.createdAt,
+    updatedAt: scenario.updatedAt
+  };
+}
+function scenarioToLines(scenario) {
+  const lines = [
+    `BDD scenario: ${scenario.name}`,
+    `Scenario id: ${scenario.id}`,
+    `Feature: ${scenario.featureName}`,
+    `Tags: ${scenario.tags.join(", ") || "none"}`,
+    `Linked issues: ${scenario.linkedIssueKeys.join(", ") || "none"}`,
+    `Created: ${scenario.createdAt}`,
+    `Updated: ${scenario.updatedAt}`,
+    "Steps:"
+  ];
+  for (const step of scenario.steps) {
+    lines.push(`- ${step.keyword} ${step.text}`);
+  }
+  return lines;
+}
+function missingProjectResponse() {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+  };
+}
+function createBddHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [subcommand, ...restArgs] = request.args;
+    const parsed = parseArgs2(restArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const config = resolveCliConfig(pickConfigArgs2(parsed), env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (!projectKey) {
+      return missingProjectResponse();
+    }
+    if (subcommand === "scenarios") {
+      const nested = restArgs[0];
+      if (nested !== "show") {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["ERROR: Unsupported bdd scenarios subcommand. Use: testops bdd scenarios show --id <SCENARIO_ID>"]
+        };
+      }
+      const scenarioId = parsed.flags["--id"]?.trim() ?? "";
+      if (!scenarioId) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: ["ERROR: Missing required --id for testops bdd scenarios show."]
+        };
+      }
+      try {
+        const result = await context.invokeForgeContract("getBddScenario", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          scenarioId
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "bdd-scenarios-show",
+              projectKey,
+              issueKey: issueKey || null,
+              item: toJsonScenario(result.data)
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: scenarioToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError(error)}`]
+        };
+      }
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [`ERROR: Unsupported bdd subcommand: ${subcommand}`]
+    };
+  };
+}
+
+// src/cases.ts
+var CONFIG_FLAGS3 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs3(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--key", ...CONFIG_FLAGS3]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!supportedValueFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    index += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs3(parsed) {
+  const args = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS3.has(flag)) {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeError2(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown cases command error.";
+}
+function toJsonCase(testCase) {
+  return {
+    id: testCase.id,
+    key: testCase.key,
+    title: testCase.title,
+    status: testCase.status,
+    description: testCase.description ?? null,
+    linkedIssueKeys: [...testCase.linkedIssueKeys ?? []],
+    createdAt: testCase.createdAt,
+    updatedAt: testCase.updatedAt
+  };
+}
+function toJsonScenario2(scenario) {
+  return {
+    id: scenario.id,
+    featureId: scenario.featureId,
+    featureName: scenario.featureName,
+    name: scenario.name,
+    tags: [...scenario.tags],
+    linkedIssueKeys: [...scenario.linkedIssueKeys],
+    steps: scenario.steps.map((step) => ({
+      keyword: step.keyword,
+      text: step.text
+    })),
+    createdAt: scenario.createdAt,
+    updatedAt: scenario.updatedAt
+  };
+}
+function toJsonRun(run) {
+  return {
+    id: run.id,
+    featureId: run.featureId ?? null,
+    scenarioId: run.scenarioId ?? null,
+    testCaseIds: [...run.testCaseIds ?? []],
+    linkedIssueKeys: [...run.linkedIssueKeys],
+    createdAt: run.createdAt,
+    payload: {
+      featureName: run.payload.featureName,
+      scenarioName: run.payload.scenarioName,
+      executedAt: run.payload.executedAt,
+      steps: run.payload.steps.map((step) => ({
+        step: step.step,
+        result: step.result,
+        error: step.error ?? null
+      }))
+    },
+    executionSummary: {
+      passed: run.executionSummary.passed,
+      failed: run.executionSummary.failed,
+      skipped: run.executionSummary.skipped,
+      blocked: run.executionSummary.blocked,
+      total: run.executionSummary.total
+    }
+  };
+}
+function listToLines(items) {
+  if (items.length === 0) {
+    return ["Test cases: 0", "No test cases found for the selected context."];
+  }
+  return [
+    `Test cases: ${items.length}`,
+    ...items.map((item) => `- ${item.key} [${item.status}] ${item.title}`)
+  ];
+}
+function showToLines(testCase) {
+  return [
+    `Test case: ${testCase.key}`,
+    `Title: ${testCase.title}`,
+    `Status: ${testCase.status}`,
+    `Description: ${testCase.description ?? "none"}`,
+    `Linked issues: ${(testCase.linkedIssueKeys ?? []).join(", ") || "none"}`,
+    `Created: ${testCase.createdAt}`,
+    `Updated: ${testCase.updatedAt}`
+  ];
+}
+function scenariosToLines(testCase, scenarios) {
+  if (scenarios.length === 0) {
+    return [
+      `Linked scenarios: 0`,
+      `Test case: ${testCase.key} ${testCase.title}`,
+      "No linked BDD scenarios were found for this test case."
+    ];
+  }
+  return [
+    `Linked scenarios: ${scenarios.length}`,
+    `Test case: ${testCase.key} ${testCase.title}`,
+    ...scenarios.map((scenario) => {
+      const tagSuffix = scenario.tags.length > 0 ? ` tags=${scenario.tags.join(",")}` : "";
+      return `- ${scenario.featureName} :: ${scenario.name} (${scenario.steps.length} steps${tagSuffix})`;
+    })
+  ];
+}
+function runsToLines(testCase, runs) {
+  if (runs.length === 0) {
+    return [
+      `Linked runs: 0`,
+      `Test case: ${testCase.key} ${testCase.title}`,
+      "No execution runs were found for this test case."
+    ];
+  }
+  return [
+    `Linked runs: ${runs.length}`,
+    `Test case: ${testCase.key} ${testCase.title}`,
+    ...runs.map(
+      (run) => `- ${run.payload.executedAt} ${run.payload.featureName} :: ${run.payload.scenarioName} [pass=${run.executionSummary.passed} fail=${run.executionSummary.failed} skip=${run.executionSummary.skipped} blocked=${run.executionSummary.blocked}]`
+    )
+  ];
+}
+function missingProjectResponse2() {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+  };
+}
+function missingKeyResponse(commandPath = "testops cases show") {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: [`ERROR: Missing required --key for ${commandPath}.`]
+  };
+}
+function createCasesHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [subcommand, ...restArgs] = request.args;
+    const parsed = parseArgs3(restArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const config = resolveCliConfig(pickConfigArgs3(parsed), env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (!projectKey) {
+      return missingProjectResponse2();
+    }
+    if (subcommand === "list") {
+      try {
+        const result = await context.invokeForgeContract("listTestCases", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          }
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "cases-list",
+              projectKey,
+              issueKey: issueKey || null,
+              count: result.data.length,
+              items: result.data.map((item) => toJsonCase(item))
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: listToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError2(error)}`]
+        };
+      }
+    }
+    if (subcommand === "show") {
+      const testCaseKey = parsed.flags["--key"]?.trim().toUpperCase() ?? "";
+      if (!testCaseKey) {
+        return missingKeyResponse();
+      }
+      const payload = {
+        context: {
+          projectKey,
+          issueKey: issueKey || void 0
+        },
+        testCaseKey
+      };
+      try {
+        const result = await context.invokeForgeContract("getTestCase", payload);
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "cases-show",
+              projectKey,
+              issueKey: issueKey || null,
+              item: toJsonCase(result.data)
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: showToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError2(error)}`]
+        };
+      }
+    }
+    if (subcommand === "bdd") {
+      const nested = restArgs[0];
+      if (nested !== "list") {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["ERROR: Unsupported cases bdd subcommand. Use: testops cases bdd list --key <TEST_CASE_KEY>"]
+        };
+      }
+      const testCaseKey = parsed.flags["--key"]?.trim().toUpperCase() ?? "";
+      if (!testCaseKey) {
+        return missingKeyResponse("testops cases bdd list");
+      }
+      try {
+        const testCaseResult = await context.invokeForgeContract("getTestCase", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          testCaseKey
+        });
+        if (!testCaseResult.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${testCaseResult.error.code}: ${testCaseResult.error.message}`]
+          };
+        }
+        const scenariosResult = await context.invokeForgeContract("listBddScenarios", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          testCaseId: testCaseResult.data.id
+        });
+        if (!scenariosResult.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${scenariosResult.error.code}: ${scenariosResult.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "cases-bdd-list",
+              projectKey,
+              issueKey: issueKey || null,
+              testCase: toJsonCase(testCaseResult.data),
+              count: scenariosResult.data.length,
+              items: scenariosResult.data.map((scenario) => toJsonScenario2(scenario))
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: scenariosToLines(testCaseResult.data, scenariosResult.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError2(error)}`]
+        };
+      }
+    }
+    if (subcommand === "runs") {
+      const nested = restArgs[0];
+      if (nested !== "list") {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["ERROR: Unsupported cases runs subcommand. Use: testops cases runs list --key <TEST_CASE_KEY>"]
+        };
+      }
+      const testCaseKey = parsed.flags["--key"]?.trim().toUpperCase() ?? "";
+      if (!testCaseKey) {
+        return missingKeyResponse("testops cases runs list");
+      }
+      try {
+        const testCaseResult = await context.invokeForgeContract("getTestCase", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          testCaseKey
+        });
+        if (!testCaseResult.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${testCaseResult.error.code}: ${testCaseResult.error.message}`]
+          };
+        }
+        const runsResult = await context.invokeForgeContract("listRunsByTestCase", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          testCaseId: testCaseResult.data.id
+        });
+        if (!runsResult.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${runsResult.error.code}: ${runsResult.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "cases-runs-list",
+              projectKey,
+              issueKey: issueKey || null,
+              testCase: toJsonCase(testCaseResult.data),
+              count: runsResult.data.length,
+              items: runsResult.data.map((run) => toJsonRun(run))
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: runsToLines(testCaseResult.data, runsResult.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError2(error)}`]
+        };
+      }
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [`ERROR: Unsupported cases subcommand: ${subcommand}`]
+    };
+  };
+}
+
+// src/doctor.ts
+var CONFIG_FLAGS4 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs4(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const valuedFlags = /* @__PURE__ */ new Set([...CONFIG_FLAGS4]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json", "--check-context"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!valuedFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs4(parsed) {
+  const configArgs = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS4.has(flag)) {
+      configArgs.push(flag, value);
+    }
+  }
+  return configArgs;
+}
+function computeOverallStatus(checks) {
+  if (checks.some((check) => check.status === "fail")) {
+    return "fail";
+  }
+  if (checks.some((check) => check.status === "warn")) {
+    return "warn";
+  }
+  return "pass";
+}
+function normalizeConnectivityError(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "unknown connectivity error";
+}
+function checkFromServiceResult(result) {
+  if (result.ok) {
+    return {
+      name: "forge_connectivity",
+      status: "pass",
+      message: "Forge contract call succeeded."
+    };
+  }
+  return {
+    name: "forge_connectivity",
+    status: "pass",
+    message: `Forge endpoint reachable (service returned ${result.error.code}).`
+  };
+}
+function toJsonPayload(summary) {
+  return {
+    status: summary.status,
+    checks: summary.checks.map((check) => ({
+      name: check.name,
+      status: check.status,
+      message: check.message
+    }))
+  };
+}
+function pickDoctorExitCode(summary) {
+  if (summary.status !== "fail") {
+    return ExitCode.Success;
+  }
+  if (summary.checks.some((check) => check.name === "arguments" && check.status === "fail")) {
+    return ExitCode.UsageError;
+  }
+  if (summary.checks.some((check) => check.name === "forge_connectivity" && check.status === "fail")) {
+    return ExitCode.TransportError;
+  }
+  return ExitCode.ValidationError;
+}
+function toHumanLines2(summary) {
+  const lines = [`Doctor preflight: ${summary.status.toUpperCase()}`];
+  for (const check of summary.checks) {
+    lines.push(`- [${check.status.toUpperCase()}] ${check.name}: ${check.message}`);
+  }
+  return lines;
+}
+function createDoctorHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [, ...subArgs] = request.args;
+    const parsed = parseArgs4(subArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const enforceContextCheck = parsed.boolFlags.has("--check-context");
+    const checks = [];
+    if (parsed.unknownFlags.length > 0) {
+      checks.push({
+        name: "arguments",
+        status: "fail",
+        message: `Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`
+      });
+      const summary2 = { status: computeOverallStatus(checks), checks };
+      return {
+        exitCode: pickDoctorExitCode(summary2),
+        stdout: useJson ? toJsonLine(toJsonPayload(summary2)) : toHumanLines2(summary2)
+      };
+    }
+    const configArgs = pickConfigArgs4(parsed);
+    const resolution = resolveCliConfig(configArgs, env, cwd);
+    const configValidation = validateCliConfigResolution(resolution);
+    checks.push({
+      name: "config_completeness",
+      status: configValidation.ok ? "pass" : "fail",
+      message: configValidation.ok ? "Required config is present." : configValidation.errors.join(" ")
+    });
+    if (configValidation.warnings.length > 0) {
+      checks.push({
+        name: "config_warnings",
+        status: "warn",
+        message: configValidation.warnings.join(" ")
+      });
+    }
+    const endpoint = env.TESTOPS_FORGE_ENDPOINT?.trim() ?? "";
+    if (!endpoint) {
+      checks.push({
+        name: "forge_endpoint",
+        status: "fail",
+        message: "Missing TESTOPS_FORGE_ENDPOINT."
+      });
+    } else {
+      checks.push({
+        name: "forge_endpoint",
+        status: "pass",
+        message: "Forge endpoint is configured."
+      });
+    }
+    const hasContext = Boolean(
+      resolution.values.projectKey || resolution.values.issueKey
+    );
+    if (enforceContextCheck || hasContext) {
+      if (!hasContext) {
+        checks.push({
+          name: "jira_context",
+          status: "warn",
+          message: "Context check requested but no JIRA_PROJECT_KEY/JIRA_ISSUE_KEY provided."
+        });
+      } else {
+        checks.push({
+          name: "jira_context",
+          status: "pass",
+          message: `Using context project=${resolution.values.projectKey || "<unset>"} issue=${resolution.values.issueKey || "<unset>"}.`
+        });
+      }
+    } else {
+      checks.push({
+        name: "jira_context",
+        status: "skip",
+        message: "Optional context check skipped. Use --check-context to enforce."
+      });
+    }
+    if (endpoint) {
+      try {
+        const connectivity = await context.invokeForgeContract("listTestCases", {
+          context: {
+            projectKey: resolution.values.projectKey || void 0,
+            issueKey: resolution.values.issueKey || void 0
+          }
+        });
+        checks.push(checkFromServiceResult(connectivity));
+      } catch (error) {
+        checks.push({
+          name: "forge_connectivity",
+          status: "fail",
+          message: normalizeConnectivityError(error)
+        });
+      }
+    } else {
+      checks.push({
+        name: "forge_connectivity",
+        status: "skip",
+        message: "Skipped because Forge endpoint is not configured."
+      });
+    }
+    const summary = {
+      status: computeOverallStatus(checks),
+      checks
+    };
+    return {
+      exitCode: pickDoctorExitCode(summary),
+      stdout: useJson ? toJsonLine(toJsonPayload(summary)) : toHumanLines2(summary)
+    };
+  };
+}
+
+// src/ingestFeature.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import path6 from "node:path";
+var CONFIG_FLAGS5 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs5(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const valuedFlags = /* @__PURE__ */ new Set(["--file", "--name", ...CONFIG_FLAGS5]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--stdin", "--json"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!valuedFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function deriveNameFromGherkin(gherkin) {
+  const lines = gherkin.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.toLowerCase().startsWith("feature:")) {
+      return trimmed.slice("feature:".length).trim();
+    }
+  }
+  return "";
+}
+function pickConfigArgs5(parsed) {
+  const configArgs = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS5.has(flag)) {
+      configArgs.push(flag, value);
+    }
+  }
+  return configArgs;
+}
+function summarizeSuccess(result) {
+  if (!result.ok) {
+    return [];
+  }
+  const payload = result.data;
+  if (!payload || typeof payload !== "object") {
+    return [];
+  }
+  const asRecord = payload;
+  const lines = [];
+  if (typeof asRecord.id === "string" && asRecord.id) {
+    lines.push(`Artifact id: ${asRecord.id}`);
+  }
+  if (typeof asRecord.projectKey === "string" && asRecord.projectKey) {
+    lines.push(`Project: ${asRecord.projectKey}`);
+  }
+  return lines;
+}
+function normalizeError3(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown ingest error.";
+}
+function createIngestFeatureHandler(deps = {}) {
+  const readFile = deps.readFile ?? ((filePath) => readFileSync4(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => readFileSync4(0, "utf8"));
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [, ...subArgs] = request.args;
+    const parsed = parseArgs5(subArgs);
+    const configArgs = pickConfigArgs5(parsed);
+    const config = resolveCliConfig(configArgs, env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    const sourceFile = parsed.flags["--file"] ? path6.resolve(cwd, parsed.flags["--file"]) : "";
+    const useStdin = parsed.boolFlags.has("--stdin");
+    const useJson = parsed.boolFlags.has("--json");
+    const sourceCount = Number(Boolean(sourceFile)) + Number(useStdin);
+    if (sourceCount !== 1) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Provide exactly one input source: --file <path> or --stdin."]
+      };
+    }
+    let gherkin = "";
+    try {
+      gherkin = useStdin ? readStdin() : readFile(sourceFile);
+    } catch (error) {
+      return {
+        exitCode: ExitCode.InternalError,
+        stderr: [`ERROR: Failed to read feature source: ${normalizeError3(error)}`]
+      };
+    }
+    const name = (parsed.flags["--name"] ?? deriveNameFromGherkin(gherkin)).trim();
+    if (!name) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Missing feature name. Pass --name or include 'Feature: <name>' in gherkin."]
+      };
+    }
+    if (!gherkin.trim()) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Gherkin content is empty."]
+      };
+    }
+    if (!projectKey) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+      };
+    }
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    const payload = {
+      context: {
+        projectKey,
+        issueKey: issueKey || void 0
+      },
+      input: {
+        name,
+        gherkin
+      }
+    };
+    try {
+      const result = await context.invokeForgeContract("ingestBddFeature", payload);
+      if (!result.ok) {
+        if (useJson) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stdout: toJsonLine({
+              action: "ingest-feature",
+              status: "failed",
+              featureName: name,
+              source: useStdin ? "stdin" : sourceFile,
+              errorCode: result.error.code,
+              errorMessage: result.error.message
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.RemoteError,
+          stdout: [
+            "Feature ingestion: FAILED",
+            `Feature: ${name}`,
+            `Source: ${useStdin ? "stdin" : sourceFile}`
+          ],
+          stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+        };
+      }
+      if (useJson) {
+        const details = summarizeSuccess(result);
+        return {
+          exitCode: ExitCode.Success,
+          stdout: toJsonLine({
+            action: "ingest-feature",
+            status: "success",
+            featureName: name,
+            source: useStdin ? "stdin" : sourceFile,
+            details
+          })
+        };
+      }
+      return {
+        exitCode: ExitCode.Success,
+        stdout: [
+          "Feature ingestion: SUCCESS",
+          `Feature: ${name}`,
+          `Source: ${useStdin ? "stdin" : sourceFile}`,
+          ...summarizeSuccess(result)
+        ]
+      };
+    } catch (error) {
+      if (useJson) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stdout: toJsonLine({
+            action: "ingest-feature",
+            status: "failed",
+            featureName: name,
+            source: useStdin ? "stdin" : sourceFile,
+            errorMessage: normalizeError3(error)
+          })
+        };
+      }
+      return {
+        exitCode: ExitCode.TransportError,
+        stdout: [
+          "Feature ingestion: FAILED",
+          `Feature: ${name}`,
+          `Source: ${useStdin ? "stdin" : sourceFile}`
+        ],
+        stderr: [`ERROR: ${normalizeError3(error)}`]
+      };
+    }
+  };
+}
+
+// src/runUpload.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+import path7 from "node:path";
+var STEP_RESULTS = [
+  StepResult.Passed,
+  StepResult.Failed,
+  StepResult.Skipped,
+  StepResult.Blocked
+];
+var CONFIG_FLAGS6 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs6(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const valuedFlags = /* @__PURE__ */ new Set([
+    "--file",
+    "--feature-name",
+    "--scenario-name",
+    "--executed-at",
+    ...CONFIG_FLAGS6
+  ]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--stdin", "--json"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!valuedFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs6(parsed) {
+  const configArgs = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS6.has(flag)) {
+      configArgs.push(flag, value);
+    }
+  }
+  return configArgs;
+}
+function normalizeError4(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown run upload error.";
+}
+function parseRunPayload(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isIsoDateTime(value) {
+  if (!value.trim()) {
+    return false;
+  }
+  return !Number.isNaN(Date.parse(value));
+}
+function validateRunInput(input) {
+  const errors = [];
+  if (!input.featureName?.trim()) {
+    errors.push("featureName is required.");
+  }
+  if (!input.scenarioName?.trim()) {
+    errors.push("scenarioName is required.");
+  }
+  if (!isIsoDateTime(input.executedAt)) {
+    errors.push("executedAt must be a valid ISO date-time.");
+  }
+  if (!Array.isArray(input.steps) || input.steps.length === 0) {
+    errors.push("steps must contain at least one item.");
+    return errors;
+  }
+  input.steps.forEach((step, index) => {
+    if (!step?.step?.trim()) {
+      errors.push(`steps[${index}].step is required.`);
+    }
+    if (!STEP_RESULTS.includes(step.result)) {
+      errors.push(`steps[${index}].result must be one of: ${STEP_RESULTS.join(", ")}.`);
+    }
+    if (step.result === StepResult.Failed && !step.error?.trim()) {
+      errors.push(`steps[${index}].error is required when result is failed.`);
+    }
+  });
+  return errors;
+}
+function mergeMetadataOverrides(input, parsed) {
+  return {
+    featureName: (parsed.flags["--feature-name"] ?? input.featureName ?? "").trim(),
+    scenarioName: (parsed.flags["--scenario-name"] ?? input.scenarioName ?? "").trim(),
+    executedAt: (parsed.flags["--executed-at"] ?? input.executedAt ?? "").trim(),
+    steps: Array.isArray(input.steps) ? input.steps : []
+  };
+}
+function summarizeRunResult(result) {
+  if (!result.ok || !result.data || typeof result.data !== "object") {
+    return [];
+  }
+  const payload = result.data;
+  const lines = [];
+  if (typeof payload.id === "string" && payload.id) {
+    lines.push(`Run artifact id: ${payload.id}`);
+  }
+  if (typeof payload.projectKey === "string" && payload.projectKey) {
+    lines.push(`Project: ${payload.projectKey}`);
+  }
+  return lines;
+}
+function createRunUploadHandler(deps = {}) {
+  const readFile = deps.readFile ?? ((filePath) => readFileSync5(filePath, "utf8"));
+  const readStdin = deps.readStdin ?? (() => readFileSync5(0, "utf8"));
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [, ...subArgs] = request.args;
+    const parsed = parseArgs6(subArgs);
+    const configArgs = pickConfigArgs6(parsed);
+    const config = resolveCliConfig(configArgs, env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    const sourceFile = parsed.flags["--file"] ? path7.resolve(cwd, parsed.flags["--file"]) : "";
+    const useStdin = parsed.boolFlags.has("--stdin");
+    const useJson = parsed.boolFlags.has("--json");
+    const sourceCount = Number(Boolean(sourceFile)) + Number(useStdin);
+    if (sourceCount !== 1) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Provide exactly one input source: --file <path> or --stdin."]
+      };
+    }
+    if (!projectKey) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+      };
+    }
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    let raw = "";
+    try {
+      raw = useStdin ? readStdin() : readFile(sourceFile);
+    } catch (error) {
+      return {
+        exitCode: ExitCode.InternalError,
+        stderr: [`ERROR: Failed to read run payload source: ${normalizeError4(error)}`]
+      };
+    }
+    const payloadFromSource = parseRunPayload(raw);
+    if (!payloadFromSource) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Run payload must be valid JSON matching BddRunInput shape."]
+      };
+    }
+    const runInput = mergeMetadataOverrides(payloadFromSource, parsed);
+    const validationErrors = validateRunInput(runInput);
+    if (validationErrors.length > 0) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: validationErrors.map((line) => `ERROR: ${line}`)
+      };
+    }
+    const payload = {
+      context: {
+        projectKey,
+        issueKey: issueKey || void 0
+      },
+      input: runInput
+    };
+    try {
+      const result = await context.invokeForgeContract("ingestBddRun", payload);
+      if (!result.ok) {
+        if (useJson) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stdout: toJsonLine({
+              action: "run-upload",
+              status: "failed",
+              featureName: runInput.featureName,
+              scenarioName: runInput.scenarioName,
+              executedAt: runInput.executedAt,
+              errorCode: result.error.code,
+              errorMessage: result.error.message
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.RemoteError,
+          stdout: [
+            "Run upload: FAILED",
+            `Feature: ${runInput.featureName}`,
+            `Scenario: ${runInput.scenarioName}`,
+            `ExecutedAt: ${runInput.executedAt}`
+          ],
+          stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+        };
+      }
+      if (useJson) {
+        return {
+          exitCode: ExitCode.Success,
+          stdout: toJsonLine({
+            action: "run-upload",
+            status: "success",
+            featureName: runInput.featureName,
+            scenarioName: runInput.scenarioName,
+            executedAt: runInput.executedAt,
+            stepCount: runInput.steps.length
+          })
+        };
+      }
+      return {
+        exitCode: ExitCode.Success,
+        stdout: [
+          "Run upload: SUCCESS",
+          `Feature: ${runInput.featureName}`,
+          `Scenario: ${runInput.scenarioName}`,
+          `ExecutedAt: ${runInput.executedAt}`,
+          `Step count: ${runInput.steps.length}`,
+          ...summarizeRunResult(result)
+        ]
+      };
+    } catch (error) {
+      if (useJson) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stdout: toJsonLine({
+            action: "run-upload",
+            status: "failed",
+            featureName: runInput.featureName,
+            scenarioName: runInput.scenarioName,
+            executedAt: runInput.executedAt,
+            errorMessage: normalizeError4(error)
+          })
+        };
+      }
+      return {
+        exitCode: ExitCode.TransportError,
+        stdout: [
+          "Run upload: FAILED",
+          `Feature: ${runInput.featureName}`,
+          `Scenario: ${runInput.scenarioName}`,
+          `ExecutedAt: ${runInput.executedAt}`
+        ],
+        stderr: [`ERROR: ${normalizeError4(error)}`]
+      };
+    }
+  };
+}
+
+// src/runs.ts
+var CONFIG_FLAGS7 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs7(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--id", ...CONFIG_FLAGS7]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!supportedValueFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    index += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs7(parsed) {
+  const args = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS7.has(flag)) {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeError5(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown runs command error.";
+}
+function toJsonRun2(run) {
+  return {
+    id: run.id,
+    featureId: run.featureId ?? null,
+    scenarioId: run.scenarioId ?? null,
+    testCaseIds: [...run.testCaseIds ?? []],
+    linkedIssueKeys: [...run.linkedIssueKeys],
+    createdAt: run.createdAt,
+    payload: {
+      featureName: run.payload.featureName,
+      scenarioName: run.payload.scenarioName,
+      executedAt: run.payload.executedAt,
+      steps: run.payload.steps.map((step) => ({
+        step: step.step,
+        result: step.result,
+        error: step.error ?? null
+      }))
+    },
+    executionSummary: {
+      passed: run.executionSummary.passed,
+      failed: run.executionSummary.failed,
+      skipped: run.executionSummary.skipped,
+      blocked: run.executionSummary.blocked,
+      total: run.executionSummary.total
+    }
+  };
+}
+function runToLines(run) {
+  const lines = [
+    `Run: ${run.id}`,
+    `Feature: ${run.payload.featureName}`,
+    `Scenario: ${run.payload.scenarioName}`,
+    `Executed at: ${run.payload.executedAt}`,
+    `Summary: pass=${run.executionSummary.passed} fail=${run.executionSummary.failed} skip=${run.executionSummary.skipped} blocked=${run.executionSummary.blocked} total=${run.executionSummary.total}`,
+    `Linked issues: ${run.linkedIssueKeys.join(", ") || "none"}`,
+    `Linked test cases: ${(run.testCaseIds ?? []).join(", ") || "none"}`,
+    "Steps:"
+  ];
+  for (const step of run.payload.steps) {
+    const errorSuffix = step.error ? ` error=${step.error}` : "";
+    lines.push(`- ${step.result}: ${step.step}${errorSuffix}`);
+  }
+  return lines;
+}
+function missingProjectResponse3() {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+  };
+}
+function createRunsHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [subcommand, ...restArgs] = request.args;
+    const parsed = parseArgs7(restArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const config = resolveCliConfig(pickConfigArgs7(parsed), env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (!projectKey) {
+      return missingProjectResponse3();
+    }
+    if (subcommand === "show") {
+      const runId = parsed.flags["--id"]?.trim() ?? "";
+      if (!runId) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: ["ERROR: Missing required --id for testops runs show."]
+        };
+      }
+      try {
+        const result = await context.invokeForgeContract("getRun", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          runId
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "runs-show",
+              projectKey,
+              issueKey: issueKey || null,
+              item: toJsonRun2(result.data)
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: runToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError5(error)}`]
+        };
+      }
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [`ERROR: Unsupported runs subcommand: ${subcommand}`]
+    };
+  };
+}
+
+// src/suites.ts
+var CONFIG_FLAGS8 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+function parseArgs8(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--key", ...CONFIG_FLAGS8]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!supportedValueFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    index += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs8(parsed) {
+  const args = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS8.has(flag)) {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeError6(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown suites command error.";
+}
+function toJsonSuite(suite) {
+  return {
+    id: suite.id,
+    key: suite.key,
+    name: suite.name,
+    description: suite.description ?? null,
+    linkedIssueKeys: [...suite.linkedIssueKeys ?? []],
+    createdAt: suite.createdAt,
+    updatedAt: suite.updatedAt
+  };
+}
+function toJsonCase2(testCase) {
+  return {
+    id: testCase.id,
+    key: testCase.key,
+    title: testCase.title,
+    status: testCase.status,
+    description: testCase.description ?? null,
+    linkedIssueKeys: [...testCase.linkedIssueKeys ?? []],
+    createdAt: testCase.createdAt,
+    updatedAt: testCase.updatedAt
+  };
+}
+function suitesToLines(items) {
+  if (items.length === 0) {
+    return ["Test suites: 0", "No test suites found for the selected context."];
+  }
+  return [
+    `Test suites: ${items.length}`,
+    ...items.map((item) => `- ${item.key} ${item.name}`)
+  ];
+}
+function suiteToLines(suite) {
+  return [
+    `Test suite: ${suite.key}`,
+    `Name: ${suite.name}`,
+    `Description: ${suite.description ?? "none"}`,
+    `Linked issues: ${(suite.linkedIssueKeys ?? []).join(", ") || "none"}`,
+    `Created: ${suite.createdAt}`,
+    `Updated: ${suite.updatedAt}`
+  ];
+}
+function suiteCasesToLines(suite, items) {
+  if (items.length === 0) {
+    return [
+      `Suite test cases: 0`,
+      `Suite: ${suite.key} ${suite.name}`,
+      "No test cases are currently linked to this suite."
+    ];
+  }
+  return [
+    `Suite test cases: ${items.length}`,
+    `Suite: ${suite.key} ${suite.name}`,
+    ...items.map((item) => `- ${item.key} [${item.status}] ${item.title}`)
+  ];
+}
+function missingProjectResponse4() {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+  };
+}
+function missingKeyResponse2(commandPath) {
+  return {
+    exitCode: ExitCode.ValidationError,
+    stderr: [`ERROR: Missing required --key for ${commandPath}.`]
+  };
+}
+function createSuitesHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [subcommand, ...restArgs] = request.args;
+    const parsed = parseArgs8(restArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const config = resolveCliConfig(pickConfigArgs8(parsed), env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (!projectKey) {
+      return missingProjectResponse4();
+    }
+    if (subcommand === "list") {
+      try {
+        const result = await context.invokeForgeContract("listTestSuites", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          }
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "suites-list",
+              projectKey,
+              issueKey: issueKey || null,
+              count: result.data.length,
+              items: result.data.map((item) => toJsonSuite(item))
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: suitesToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    const suiteKey = parsed.flags["--key"]?.trim().toUpperCase() ?? "";
+    if (subcommand === "show") {
+      if (!suiteKey) {
+        return missingKeyResponse2("testops suites show");
+      }
+      try {
+        const result = await context.invokeForgeContract("getTestSuite", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          },
+          suiteKey
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "suites-show",
+              projectKey,
+              issueKey: issueKey || null,
+              item: toJsonSuite(result.data)
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: suiteToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    if (subcommand === "cases") {
+      const nested = restArgs[0];
+      if (nested !== "list") {
+        return {
+          exitCode: ExitCode.UsageError,
+          stderr: ["ERROR: Unsupported suites cases subcommand. Use: testops suites cases list --key <SUITE_KEY>"]
+        };
+      }
+      if (!suiteKey) {
+        return missingKeyResponse2("testops suites cases list");
+      }
+      try {
+        const [suiteResult, casesResult] = await Promise.all([
+          context.invokeForgeContract("getTestSuite", {
+            context: {
+              projectKey,
+              issueKey: issueKey || void 0
+            },
+            suiteKey
+          }),
+          context.invokeForgeContract("listSuiteTestCases", {
+            context: {
+              projectKey,
+              issueKey: issueKey || void 0
+            },
+            suiteKey
+          })
+        ]);
+        if (!suiteResult.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${suiteResult.error.code}: ${suiteResult.error.message}`]
+          };
+        }
+        if (!casesResult.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${casesResult.error.code}: ${casesResult.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "suites-cases-list",
+              projectKey,
+              issueKey: issueKey || null,
+              suite: toJsonSuite(suiteResult.data),
+              count: casesResult.data.length,
+              items: casesResult.data.map((item) => toJsonCase2(item))
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: suiteCasesToLines(suiteResult.data, casesResult.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError6(error)}`]
+        };
+      }
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [`ERROR: Unsupported suites subcommand: ${subcommand}`]
+    };
+  };
+}
+
+// src/sync.ts
+var CONFIG_FLAGS9 = /* @__PURE__ */ new Set([
+  "--config",
+  "--base-url",
+  "--project-key",
+  "--issue-key",
+  "--auth-mode",
+  "--jira-email",
+  "--jira-api-token"
+]);
+var RECONCILE_CONFIRM_TOKEN = "RECONCILE";
+function parseArgs9(args) {
+  const flags = {};
+  const boolFlags = /* @__PURE__ */ new Set();
+  const unknownFlags = [];
+  const supportedValueFlags = /* @__PURE__ */ new Set(["--confirm", ...CONFIG_FLAGS9]);
+  const supportedBoolFlags = /* @__PURE__ */ new Set(["--json"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    if (supportedBoolFlags.has(token)) {
+      boolFlags.add(token);
+      continue;
+    }
+    if (!supportedValueFlags.has(token)) {
+      unknownFlags.push(token);
+      continue;
+    }
+    const value = args[i + 1];
+    if (!value || value.startsWith("--")) {
+      unknownFlags.push(token);
+      continue;
+    }
+    flags[token] = value;
+    i += 1;
+  }
+  return { flags, boolFlags, unknownFlags };
+}
+function pickConfigArgs9(parsed) {
+  const args = [];
+  for (const [flag, value] of Object.entries(parsed.flags)) {
+    if (CONFIG_FLAGS9.has(flag)) {
+      args.push(flag, value);
+    }
+  }
+  return args;
+}
+function normalizeError7(error) {
+  if (error instanceof ForgeClientError) {
+    return `${error.code}: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown sync command error.";
+}
+function statusToLines(status) {
+  const counts = `Issues: ${status.issueCount}, test cases: ${status.testCaseCount}, features: ${status.bddFeatureCount}, runs: ${status.bddRunCount}`;
+  const errorSummary = status.errorSummary ? `Error summary: conflict ${status.errorSummary.conflict}, mapping ${status.errorSummary.mapping}, validation ${status.errorSummary.validation}, internal ${status.errorSummary.internal}` : "Error summary: unavailable";
+  return [
+    "Sync status: SUCCESS",
+    `Project: ${status.projectKey}`,
+    `Last success: ${status.lastSuccessAt ?? "none"}`,
+    `Updated at: ${status.updatedAt}`,
+    counts,
+    errorSummary,
+    `Recent errors: ${status.recentErrors.length}`
+  ];
+}
+function reconcileToLines(payload) {
+  const optionalDetails = [];
+  if (typeof payload.conflictCount === "number") {
+    optionalDetails.push(`Conflicts: ${payload.conflictCount}`);
+  }
+  if (typeof payload.issueMappingsWritten === "number") {
+    optionalDetails.push(`Issue mappings written: ${payload.issueMappingsWritten}`);
+  }
+  if (typeof payload.keyIndexEntriesWritten === "number") {
+    optionalDetails.push(`Key-index entries written: ${payload.keyIndexEntriesWritten}`);
+  }
+  if (typeof payload.staleIssueMappingsRemoved === "number") {
+    optionalDetails.push(`Stale issue mappings removed: ${payload.staleIssueMappingsRemoved}`);
+  }
+  if (typeof payload.staleKeyIndexEntriesRemoved === "number") {
+    optionalDetails.push(`Stale key-index entries removed: ${payload.staleKeyIndexEntriesRemoved}`);
+  }
+  return [
+    "Sync reconcile: SUCCESS",
+    `Reconciled at: ${payload.reconciledAt}`,
+    `Issue count: ${payload.issueCount}`,
+    ...optionalDetails
+  ];
+}
+function createSyncHandler(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  return async (request, context) => {
+    const [subcommand, ...restArgs] = request.args;
+    const parsed = parseArgs9(restArgs);
+    const useJson = parsed.boolFlags.has("--json");
+    const config = resolveCliConfig(pickConfigArgs9(parsed), env, cwd);
+    const projectKey = config.values.projectKey;
+    const issueKey = config.values.issueKey;
+    if (parsed.unknownFlags.length > 0) {
+      return {
+        exitCode: ExitCode.UsageError,
+        stderr: [`ERROR: Unknown or invalid flags: ${parsed.unknownFlags.join(", ")}`]
+      };
+    }
+    if (!projectKey) {
+      return {
+        exitCode: ExitCode.ValidationError,
+        stderr: ["ERROR: Missing project context. Set JIRA_PROJECT_KEY or pass --project-key."]
+      };
+    }
+    if (subcommand === "status") {
+      try {
+        const result = await context.invokeForgeContract("getSyncStatus", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          }
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "sync-status",
+              projectKey: result.data.projectKey,
+              issueCount: result.data.issueCount,
+              testCaseCount: result.data.testCaseCount,
+              bddFeatureCount: result.data.bddFeatureCount,
+              bddRunCount: result.data.bddRunCount,
+              recentErrorCount: result.data.recentErrors.length
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: statusToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError7(error)}`]
+        };
+      }
+    }
+    if (subcommand === "reconcile") {
+      const confirmation = parsed.flags["--confirm"] ?? "";
+      if (confirmation !== RECONCILE_CONFIRM_TOKEN) {
+        return {
+          exitCode: ExitCode.ValidationError,
+          stderr: [
+            `ERROR: Reconcile requires explicit confirmation.`,
+            `Use: testops sync reconcile --confirm ${RECONCILE_CONFIRM_TOKEN}`
+          ]
+        };
+      }
+      try {
+        const result = await context.invokeForgeContract("reconcileSync", {
+          context: {
+            projectKey,
+            issueKey: issueKey || void 0
+          }
+        });
+        if (!result.ok) {
+          return {
+            exitCode: ExitCode.RemoteError,
+            stderr: [`ERROR: ${result.error.code}: ${result.error.message}`]
+          };
+        }
+        if (useJson) {
+          return {
+            exitCode: ExitCode.Success,
+            stdout: toJsonLine({
+              action: "sync-reconcile",
+              reconciledAt: result.data.reconciledAt,
+              issueCount: result.data.issueCount,
+              conflictCount: result.data.conflictCount ?? 0
+            })
+          };
+        }
+        return {
+          exitCode: ExitCode.Success,
+          stdout: reconcileToLines(result.data)
+        };
+      } catch (error) {
+        return {
+          exitCode: ExitCode.TransportError,
+          stderr: [`ERROR: ${normalizeError7(error)}`]
+        };
+      }
+    }
+    return {
+      exitCode: ExitCode.UsageError,
+      stderr: [`ERROR: Unsupported sync subcommand: ${subcommand}`]
+    };
+  };
+}
+
+// src/registry.ts
+var COMMAND_REGISTRY = [
+  {
+    name: "auto",
+    description: "Smart auto-ingestion command contract (MVP staged)",
+    subcommands: [],
+    directInvocation: true,
+    handler: createAutoHandler()
+  },
+  {
+    name: "bdd",
+    description: "BDD scenario inspection commands",
+    subcommands: ["scenarios"],
+    handler: createBddHandler()
+  },
+  {
+    name: "cases",
+    description: "Hierarchy-aware test case browse commands",
+    subcommands: ["list", "show", "bdd", "runs"],
+    handler: createCasesHandler()
+  },
+  {
+    name: "config",
+    description: "Configuration and auth bootstrap commands",
+    subcommands: ["show", "validate"],
+    handler: createConfigHandler()
+  },
+  {
+    name: "ingest",
+    description: "BDD/test artifact ingestion commands",
+    subcommands: ["feature"],
+    handler: createIngestFeatureHandler()
+  },
+  {
+    name: "run",
+    description: "Execution result upload commands",
+    subcommands: ["upload"],
+    handler: createRunUploadHandler()
+  },
+  {
+    name: "runs",
+    description: "Execution result inspection commands",
+    subcommands: ["show"],
+    handler: createRunsHandler()
+  },
+  {
+    name: "suites",
+    description: "Hierarchy-aware suite browse commands",
+    subcommands: ["list", "show", "cases"],
+    handler: createSuitesHandler()
+  },
+  {
+    name: "doctor",
+    description: "Preflight and health checks",
+    subcommands: ["check"],
+    handler: createDoctorHandler()
+  },
+  {
+    name: "sync",
+    description: "Optional sync commands (architecture-gated)",
+    subcommands: ["status", "reconcile"],
+    gated: true,
+    handler: createSyncHandler()
+  }
+];
+function createThinClientContext() {
+  const endpoint = process.env.TESTOPS_FORGE_ENDPOINT?.trim() ?? "";
+  const authToken = process.env.TESTOPS_FORGE_AUTH_TOKEN?.trim() ?? "";
+  if (!endpoint) {
+    return {
+      invokeForgeContract: async (_contractName, _payload) => {
+        throw new Error(
+          "Missing TESTOPS_FORGE_ENDPOINT for Forge contract transport. Thin-client command handlers must call Forge contracts."
+        );
+      }
+    };
+  }
+  const timeoutMs = Number(process.env.TESTOPS_FORGE_TIMEOUT_MS ?? "30000");
+  const maxRetries = Number(process.env.TESTOPS_FORGE_MAX_RETRIES ?? "2");
+  const retryDelayMs = Number(process.env.TESTOPS_FORGE_RETRY_DELAY_MS ?? "250");
+  const client = createForgeApiClient({
+    endpoint,
+    authToken,
+    timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 3e4,
+    maxRetries: Number.isFinite(maxRetries) && maxRetries >= 0 ? maxRetries : 2,
+    retryDelayMs: Number.isFinite(retryDelayMs) && retryDelayMs > 0 ? retryDelayMs : 250
+  });
+  return {
+    invokeForgeContract: (contractName, payload) => {
+      return client.invoke(contractName, payload);
+    }
+  };
+}
+
+// src/main.ts
+var HEADER = "Automatify TestOps CLI (Forge-first thin client)";
+var COMMAND_PREFIX = "automatify testops";
+var SYNC_GATE_HINT = "Enable optional sync commands with TESTOPS_ENABLE_SYNC=1.";
+function formatSubcommands(subcommands) {
+  return subcommands.length === 0 ? "" : ` [${subcommands.join("|")}]`;
+}
+function findCommand(commandName, registry) {
+  return registry.find((command) => command.name === commandName);
+}
+function listVisibleCommands(registry, experimentalSyncEnabled) {
+  return registry.filter((command) => !command.gated || experimentalSyncEnabled);
+}
+function emitResponse(io, response) {
+  for (const line of response.stdout ?? []) {
+    io.log(line);
+  }
+  for (const line of response.stderr ?? []) {
+    io.error(line);
+  }
+}
+function buildGroupHelp(command) {
+  return [
+    `${command.name} commands`,
+    "",
+    `Usage: ${COMMAND_PREFIX} ${command.name}${formatSubcommands(command.subcommands)} [options]`,
+    "",
+    `Description: ${command.description}`,
+    "",
+    "Boundary:",
+    "  This command group is a thin wrapper over Forge contracts."
+  ].join("\n");
+}
+function buildHelpText(registry = COMMAND_REGISTRY, experimentalSyncEnabled = false) {
+  const visibleCommands = listVisibleCommands(registry, experimentalSyncEnabled);
+  const lines = [
+    HEADER,
+    "",
+    "Usage:",
+    `  ${COMMAND_PREFIX} --help`,
+    `  ${COMMAND_PREFIX} <command> [subcommand] [options]`,
+    "",
+    "Available command groups:"
+  ];
+  for (const command of visibleCommands) {
+    lines.push(
+      `  ${command.name.padEnd(12)} ${command.description}${formatSubcommands(command.subcommands)}`
+    );
+  }
+  lines.push(
+    "",
+    "Boundary:",
+    "  Thin client over Forge contracts only.",
+    "  Command handlers must delegate to Forge resolver/webtrigger contracts."
+  );
+  if (!experimentalSyncEnabled) {
+    lines.push("", `Optional gated group: sync (${SYNC_GATE_HINT})`);
+  }
+  return lines.join("\n");
+}
+function runCli(args, io = console, options = {}) {
+  const experimentalSyncEnabled = options.experimentalSyncEnabled ?? process.env.TESTOPS_ENABLE_SYNC === "1";
+  const registry = options.registry ?? COMMAND_REGISTRY;
+  const context = options.context ?? createThinClientContext();
+  const [groupArg, subcommandArg, ...restArgs] = args;
+  if (!groupArg || groupArg === "--help" || groupArg === "-h" || groupArg === "help") {
+    io.log(buildHelpText(registry, experimentalSyncEnabled));
+    return Promise.resolve(ExitCode.Success);
+  }
+  const command = findCommand(groupArg, registry);
+  if (!command) {
+    io.error(`Unknown command group: ${groupArg}`);
+    io.error(`Run \`${COMMAND_PREFIX} --help\` to see available command groups.`);
+    return Promise.resolve(ExitCode.UsageError);
+  }
+  if (command.gated && !experimentalSyncEnabled) {
+    io.error(`Command group '${command.name}' is disabled by default.`);
+    io.error(SYNC_GATE_HINT);
+    return Promise.resolve(ExitCode.UsageError);
+  }
+  if (command.directInvocation) {
+    if (subcommandArg === "--help" || subcommandArg === "-h" || subcommandArg === "help") {
+      io.log(buildAutoContractHelp());
+      return Promise.resolve(ExitCode.Success);
+    }
+    const directArgs = subcommandArg ? [subcommandArg, ...restArgs] : [...restArgs];
+    return Promise.resolve(
+      command.handler(
+        {
+          group: command.name,
+          args: directArgs,
+          rawArgs: args
+        },
+        context
+      )
+    ).then((response) => {
+      emitResponse(io, response);
+      return response.exitCode;
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : "Unknown CLI execution error.";
+      io.error(`Command execution failed: ${message}`);
+      return ExitCode.InternalError;
+    });
+  }
+  if (!subcommandArg || subcommandArg === "--help" || subcommandArg === "-h" || subcommandArg === "help") {
+    io.log(buildGroupHelp(command));
+    return Promise.resolve(ExitCode.Success);
+  }
+  if (!command.subcommands.includes(subcommandArg)) {
+    io.error(`Unknown subcommand '${subcommandArg}' for '${command.name}'.`);
+    io.error(`Run '${COMMAND_PREFIX} ${command.name} --help' to see supported subcommands.`);
+    return Promise.resolve(ExitCode.UsageError);
+  }
+  return Promise.resolve(
+    command.handler(
+      {
+        group: command.name,
+        args: [subcommandArg, ...restArgs],
+        rawArgs: args
+      },
+      context
+    )
+  ).then((response) => {
+    emitResponse(io, response);
+    return response.exitCode;
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown CLI execution error.";
+    io.error(`Command execution failed: ${message}`);
+    return ExitCode.InternalError;
+  });
+}
+
+// src/index.ts
+var HEADER2 = "Automatify CLI";
+function showTopLevelHelp() {
+  const lines = [
+    HEADER2,
+    "",
+    "Usage:",
+    "  automatify --help",
+    "  automatify <product> [command] [options]",
+    "",
+    "Available products:",
+    "  testops       TestOps \u2014 test management, BDD, execution, reporting",
+    "",
+    "Boundary:",
+    "  Thin client over Forge contracts only.",
+    "  No separate backend, no duplicate domain logic."
+  ];
+  for (const line of lines) {
+    console.log(line);
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const [productArg, ...restArgs] = args;
+  if (!productArg || productArg === "--help" || productArg === "-h" || productArg === "help") {
+    showTopLevelHelp();
+    process.exitCode = 0;
+    return;
+  }
+  if (productArg !== "testops") {
+    console.error(`Unknown product: ${productArg}`);
+    console.error("Run `automatify --help` to see available products.");
+    process.exitCode = 1;
+    return;
+  }
+  const exitCode = await runCli(restArgs);
+  process.exitCode = exitCode;
+}
+main();