badgr-cli 1.0.44 → 1.0.45

package/src/commands/serve.js

@@ -4,7 +4,7 @@ import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { formatCliError } from '../errors.js';
 import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides, BLESSED_VLLM_MODELS, isLikelyGatedModel } from '../catalog.js';
-import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock } from '../progress.js';
+import { stage as _stage, stageDone as _stageDone, writeBlock as _writeBlock, clearBlock as _clearBlock, renderLiveBlock as _renderLiveBlock, printFailureClass as _printFailureClass } from '../progress.js';
 
 const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
@@ -150,7 +150,12 @@ async function waitForEndpoint(deploymentId, config, timeoutMs = VLLM_SERVE_WAIT
       });
       if (['failed', 'terminated', 'error', 'stopped'].includes(dep.status)) {
         if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
-        return { ready: false, timedOut: false, depFailed: true, failReason: dep.fix_hint || dep.error || dep.status };
+        return {
+          ready: false, timedOut: false, depFailed: true,
+          failReason: dep.fix_hint || dep.error || dep.status,
+          failureClass: dep.failure_class ?? null,
+          nextAction: dep.next_action ?? null,
+        };
       }
       if (dep.endpoint_ready) {
         if (blockLines > 0) { _clearBlock(blockLines); blockLines = 0; }
@@ -208,6 +213,101 @@ const _KNOWN_SERVE_FLAGS = new Set([
   '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file',
 ]);
 
+function extractFlag(args, flagName) {
+  const rest = [];
+  let value = null;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === flagName) { value = args[++i]; continue; }
+    rest.push(args[i]);
+  }
+  return { value, rest };
+}
+
+// Returns { id, endpointUrl } for a running vLLM endpoint matching modelId, or
+// null. The id is needed so a caller that auto-launches a new one can print a
+// precise `badgr down <id>` hint if something later fails.
+async function findRunningVllmEndpoint(config, modelId) {
+  try {
+    const existing = await listDeployments(config);
+    const ACTIVE = new Set(['running', 'provisioning', 'starting', 'queued']);
+    const match = (existing.deployments ?? []).find(d =>
+      ACTIVE.has(d.status) && d.workload_type === 'endpoint' && d.model === modelId
+    );
+    if (!match) return null;
+    const endpointUrl = match.endpoint_url || match.openai_base_url || null;
+    return endpointUrl ? { id: match.deployment_id, endpointUrl } : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `badgr serve openwebui [--model <alias-or-id>] [--connect <url>] [flags]`
+ *
+ * Open WebUI serves a chat UI that connects to a model endpoint — usually
+ * vLLM. It is a separate served app from the model itself: this reuses a
+ * running vLLM endpoint for the model if one exists, or launches one via
+ * `serveCommand` first, then launches Open WebUI wired to it via
+ * OPENAI_API_BASE_URL/OPENAI_API_KEY. `--connect` skips vLLM discovery/launch
+ * entirely and points Open WebUI at any existing OpenAI-compatible endpoint —
+ * no model is ever touched in that mode.
+ */
+async function serveOpenWebUICommand(config, args, chalk) {
+  requireApiKey(config);
+  const { value: connect, rest: afterConnect } = extractFlag(args, '--connect');
+  const { value: model, rest } = extractFlag(afterConnect, '--model');
+
+  let endpointUrl = connect || null;
+  let launchedVllmDepId = null; // set only if we launched a new vLLM (for cleanup hints)
+
+  if (!endpointUrl) {
+    const alias = model || 'qwen-7b';
+    const vllmAlias = BLESSED_VLLM_MODELS[alias];
+    const modelId = vllmAlias ? vllmAlias.model_id : alias;
+
+    const existing = await findRunningVllmEndpoint(config, modelId);
+    if (existing) {
+      endpointUrl = existing.endpointUrl;
+      console.log(chalk.dim(`  Reusing running vLLM endpoint for ${modelId}: ${endpointUrl}\n`));
+    } else {
+      // Auto-launching vLLM reuses rest's --max-cost/--persistent, which also
+      // apply to Open WebUI below — that's two separately billed deployments,
+      // not a shared budget, so say so instead of a silent double spend.
+      const { value: webuiMaxCost } = extractFlag(rest, '--max-cost');
+      console.log(chalk.bold(`\n  Open WebUI needs a model endpoint behind it — no running vLLM endpoint for ${modelId} found.\n`));
+      if (webuiMaxCost) {
+        console.log(chalk.yellow(`  Launching vLLM first with its own --max-cost $${webuiMaxCost} cap (separate from Open WebUI's).`));
+        console.log(chalk.yellow(`  Total possible spend across both deployments: ~$${(parseFloat(webuiMaxCost) * 2).toFixed(2)}.\n`));
+      }
+      await serveCommand(config, [alias, ...rest], chalk);
+      const launched = await findRunningVllmEndpoint(config, modelId);
+      if (!launched) {
+        console.error(chalk.red(`\n  ✗ vLLM endpoint for ${modelId} did not come up — see output above.\n`));
+        console.error(chalk.dim(`  Once it's ready, run: badgr serve openwebui --connect <endpoint-url>\n`));
+        process.exitCode = 1;
+        return;
+      }
+      endpointUrl = launched.endpointUrl;
+      launchedVllmDepId = launched.id;
+    }
+  }
+
+  const overrides = parseTemplateOverrides(rest);
+  // User-supplied --env intentionally wins over the auto-wired connection env.
+  overrides.env = {
+    OPENAI_API_BASE_URL: endpointUrl,
+    OPENAI_API_KEY:      config.apiKey || 'sk-local',
+    ...overrides.env,
+  };
+  const flags = buildTemplateFlags(TEMPLATE_MAP.openwebui, overrides);
+  await serveCommand(config, flags, chalk);
+
+  if (process.exitCode && launchedVllmDepId) {
+    console.error(chalk.yellow(`\n  Open WebUI failed to start. The vLLM endpoint it was connecting to is still running and billing separately.`));
+    console.error(chalk.dim(`  Stop it with: badgr down ${launchedVllmDepId}\n`));
+  }
+}
+
 export async function serveCommand(config, args, chalk) {
   // `badgr serve template <name> [flags]` — expand template defaults then re-dispatch
   if (args[0] === 'template') {
@@ -230,6 +330,12 @@ export async function serveCommand(config, args, chalk) {
     return serveCommand(config, expandedArgs, chalk);
   }
 
+  // `badgr serve openwebui|open-webui [flags]` — a chat UI that connects to a
+  // model endpoint (usually vLLM). See serveOpenWebUICommand.
+  if (args[0] && ['openwebui', 'open-webui'].includes(args[0].toLowerCase())) {
+    return serveOpenWebUICommand(config, args.slice(1), chalk);
+  }
+
   if (args.includes('--list-aliases')) {
     console.log(chalk.bold('\nTested model routes:\n'));
     for (const alias of Object.keys(BLESSED_VLLM_MODELS)) {
@@ -536,11 +642,12 @@ export async function serveCommand(config, args, chalk) {
 
   // Shared reporting for "deployment failed to start" — hit from both the
   // pre-poll status check and the waitForEndpoint poll loop below.
-  function reportDeployFailure(failReason) {
+  function reportDeployFailure(failReason, failureInfo = {}) {
     console.error(formatCliError('HEALTH_CHECK_DEPLOY_FAILED', {
       deploymentId: dep.deployment_id,
       failReason,
     }, chalk));
+    _printFailureClass(chalk, { failure_class: failureInfo.failureClass, next_action: failureInfo.nextAction });
     if (gatedHintNeeded) {
       const rerun = args.join(' ');
       const retryCmd = rerun.includes('HF_TOKEN=') ? rerun : `${rerun} --env HF_TOKEN=$HF_TOKEN`;
@@ -578,7 +685,9 @@ export async function serveCommand(config, args, chalk) {
         timeoutMs: 10_000,
       });
       if (['failed', 'terminated', 'error'].includes(latest.status)) {
-        reportDeployFailure(latest.error || latest.status);
+        reportDeployFailure(latest.error || latest.status, {
+          failureClass: latest.failure_class ?? null, nextAction: latest.next_action ?? null,
+        });
         return;
       }
     } catch {
@@ -592,7 +701,9 @@ export async function serveCommand(config, args, chalk) {
     );
 
     if (healthResult.depFailed) {
-      reportDeployFailure(healthResult.failReason);
+      reportDeployFailure(healthResult.failReason, {
+        failureClass: healthResult.failureClass, nextAction: healthResult.nextAction,
+      });
       return;
     }
 

package/src/commands/train.js

@@ -10,6 +10,7 @@ import { requireApiKey } from '../config.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { monitorBatchJob, fmtRuntime } from '../batch.js';
+import { pollJobUntilTerminal, renderJobClosingBlock } from '../progress.js';
 
 const MAX_CONFIG_B = 512 * 1024; // 512 KB config limit
 
@@ -239,35 +240,29 @@ export async function trainLoraCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}`);
   console.log(chalk.dim('\n  Polling for completion — Ctrl+C to detach (GPU keeps running)\n'));
 
-  // Poll until complete
-  const startMs = Date.now();
   const maxMs = maxRuntime * 60 * 1000;
-  while (Date.now() - startMs < maxMs) {
-    await new Promise(r => setTimeout(r, 15_000));
-    let detail;
-    try {
-      detail = await callApi(`/jobs/${job.job_id}`, {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-      });
-    } catch { continue; }
-    process.stdout.write(`\r  Status: ${detail.status}  elapsed: ${Math.floor((Date.now() - startMs) / 1000)}s  `);
-    if (detail.status === 'completed') {
-      const out = detail.output || {};
-      console.log(chalk.green('\n\n  ✓ Training complete\n'));
-      if (out.adapter_url) console.log(`  ${chalk.bold('Adapter:')} ${out.adapter_url}`);
-      if (out.checkpoint_url) console.log(`  ${chalk.bold('Checkpoint:')} ${out.checkpoint_url}`);
-      console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}\n`);
-      return;
-    }
-    if (detail.status === 'failed') {
-      console.error(chalk.red(`\n\n  ✗ Training failed: ${detail.error_code || ''} — ${detail.error_message || ''}\n`));
-      process.exitCode = 1;
-      return;
-    }
+  const { outcome, detail } = await pollJobUntilTerminal(callApi, config, job.job_id, { chalk, maxMs });
+
+  if (outcome === 'polling_failed') {
+    console.error(chalk.red(`\n\n  ✗ Lost contact with Badgr — could not confirm job status.\n`));
+    console.error(chalk.dim(`    badgr status\n    badgr logs ${job.job_id}\n`));
+    process.exitCode = 1;
+    return;
+  }
+  if (outcome === 'timed_out') {
+    console.error(chalk.yellow('\n\n  Training still running — detached. Check status:\n'));
+    console.error(chalk.dim(`    badgr status\n`));
+    return;
+  }
+
+  if (outcome === 'completed') {
+    const out = detail.output || {};
+    if (out.adapter_url) console.log(`\n  ${chalk.bold('Adapter:')} ${out.adapter_url}`);
+    if (out.checkpoint_url) console.log(`  ${chalk.bold('Checkpoint:')} ${out.checkpoint_url}`);
+    if (out.warning) console.log(chalk.yellow(`  ${out.warning}`));
   }
-  console.error(chalk.yellow('\n\n  Training still running — detached. Check status:\n'));
-  console.error(chalk.dim(`    badgr status\n`));
+  console.log(renderJobClosingBlock(chalk, detail, rcptId));
+  if (outcome === 'failed') process.exitCode = 1;
 }
 
 export async function trainCommand(config, args, chalk) {

package/src/detect.js

@@ -0,0 +1,362 @@
+/**
+ * Workload detection — infer how to run an arbitrary GPU project from its
+ * files, without asking the user to describe their infrastructure.
+ *
+ * Domain-agnostic by design: no code path here is specific to any one
+ * framework (ComfyUI, vLLM, RunPod, etc.) or provider. Detection works off
+ * generic, corroborating file/content signals — entry-point filenames,
+ * dependency manifests, port/health conventions, model-reference patterns —
+ * so the same engine covers custom scripts, endpoints, batch jobs, and
+ * training repos alike. Framework-specific signals are just additional
+ * evidence fed into the same generic scoring, never a special-cased branch.
+ *
+ * Pure and local: reads files under the target directory only, makes no
+ * network calls, and never reveals provider/routing details — that's the
+ * caller's job (see commands/detect.js and commands/run.js).
+ */
+import fs from 'fs';
+import path from 'path';
+
+// Mirrors _ZIP_EXCLUDES in commands/run.js — directories we never walk into.
+const SKIP_DIRS = new Set([
+  '.git', 'node_modules', '__pycache__', '.venv', 'venv', 'env',
+  'dist', 'build', '.next', '.nuxt', 'coverage', '.pytest_cache',
+  '.mypy_cache', '.ruff_cache', '.DS_Store', '.idea', '.vscode',
+]);
+
+const MAX_READ_BYTES = 200_000; // don't slurp huge files for signal-scanning
+const MAX_WALK_ENTRIES = 5000;  // safety bound on very large trees
+
+function safeReadText(absPath) {
+  try {
+    const stat = fs.statSync(absPath);
+    if (!stat.isFile() || stat.size > 5_000_000) return '';
+    const fd = fs.openSync(absPath, 'r');
+    const len = Math.min(stat.size, MAX_READ_BYTES);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, 0);
+    fs.closeSync(fd);
+    return buf.toString('utf8');
+  } catch {
+    return '';
+  }
+}
+
+function walk(dir, files = [], depth = 0) {
+  if (files.length >= MAX_WALK_ENTRIES || depth > 8) return files;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    if (files.length >= MAX_WALK_ENTRIES) break;
+    if (entry.name.startsWith('.') && !['.env.example'].includes(entry.name)) {
+      if (entry.isDirectory()) continue;
+    }
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      walk(abs, files, depth + 1);
+    } else {
+      files.push(abs);
+    }
+  }
+  return files;
+}
+
+// ── Signal catalogs (generic — ordered by how strongly they imply an entry point) ──
+
+const ENTRYPOINT_CANDIDATES = [
+  'main.py', 'app.py', 'server.py', 'run.py', 'predict.py', 'inference.py',
+  'handler.py', 'rp_handler.py', 'worker.py', 'train.py', 'finetune.py',
+  'generate.py', 'transcribe.py', 'index.js', 'server.js', 'main.js',
+];
+
+const REQUIREMENTS_FILES = [
+  'requirements.txt', 'pyproject.toml', 'environment.yml', 'environment.yaml',
+  'Pipfile', 'package.json', 'setup.py', 'poetry.lock',
+];
+
+const MODEL_DIR_NAMES = ['models', 'checkpoints', 'ckpt', 'weights', 'model'];
+const INPUT_DIR_NAMES = ['input', 'inputs', 'data', 'dataset', 'datasets'];
+const OUTPUT_DIR_NAMES = ['output', 'outputs', 'out', 'results', 'generated'];
+const CHECKPOINT_DIR_NAMES = ['checkpoints', 'checkpoint', 'ckpt', 'ckpts'];
+
+const HF_REPO_RE = /\b[a-zA-Z0-9][\w.-]{1,60}\/[a-zA-Z0-9][\w.-]{1,80}\b/g;
+const WEIGHT_FILE_RE = /[\w.-]+\.(safetensors|ckpt|gguf|bin|pt|pth|onnx)\b/gi;
+const PARAM_SIZE_RE = /\b(\d{1,3})\s*[bB]\b/g;
+
+// ── File-content sniffers ────────────────────────────────────────────────
+
+function detectPorts(files) {
+  const ports = new Set();
+  for (const f of files) {
+    const base = path.basename(f);
+    const text = base === 'Dockerfile' || /\.(py|js|ts|toml|ya?ml)$/.test(base)
+      ? safeReadText(f) : '';
+    if (!text) continue;
+    for (const m of text.matchAll(/\bEXPOSE\s+(\d{2,5})/gi)) ports.add(Number(m[1]));
+    for (const m of text.matchAll(/\bport\s*[=:]\s*(\d{2,5})\b/gi)) ports.add(Number(m[1]));
+    for (const m of text.matchAll(/--port[= ](\d{2,5})/g)) ports.add(Number(m[1]));
+  }
+  return [...ports];
+}
+
+function detectModelRefs(files) {
+  const refs = new Set();
+  for (const f of files) {
+    const base = path.basename(f);
+    if (!/\.(py|json|ya?ml|toml|txt|md)$/.test(base)) continue;
+    const text = safeReadText(f);
+    if (!text) continue;
+    for (const m of text.matchAll(WEIGHT_FILE_RE)) refs.add(m[0]);
+    for (const m of text.matchAll(/\b(base_model|model_name|model_id|MODEL_NAME|--model)\s*[:=]\s*["']?([\w./-]+)["']?/g)) {
+      refs.add(m[2]);
+    }
+    // Hugging Face "org/name" style refs — only keep ones that look plausible
+    // (avoid matching file paths like src/foo by requiring at least one dot-free segment
+    // and no leading './').
+    for (const m of text.matchAll(HF_REPO_RE)) {
+      const val = m[0];
+      if (val.startsWith('.') || val.includes('://') || /\.(py|js|ts|json|ya?ml|txt|md|toml)$/.test(val)) continue;
+      if (/^(https?|import|from|src|lib|utils|tests?|scripts?|docs?)\//.test(val)) continue;
+      if (val.split('/').length !== 2) continue;
+      refs.add(val);
+    }
+  }
+  return [...refs].slice(0, 20);
+}
+
+function listDirsMatching(rootFiles, rootDir, names) {
+  const found = new Set();
+  for (const name of names) {
+    const abs = path.join(rootDir, name);
+    if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) found.add(name + '/');
+  }
+  return [...found];
+}
+
+function estimateVramFromModelRefs(refs, workloadType) {
+  let maxB = 0;
+  for (const ref of refs) {
+    for (const m of ref.matchAll(PARAM_SIZE_RE)) {
+      const n = parseInt(m[1], 10);
+      if (n > maxB && n <= 700) maxB = n;
+    }
+  }
+  if (maxB > 0) {
+    if (maxB <= 3) return '8+ GB';
+    if (maxB <= 8) return '16+ GB';
+    if (maxB <= 14) return '24+ GB';
+    if (maxB <= 34) return '40+ GB';
+    return '80+ GB';
+  }
+  const defaults = {
+    training: '40+ GB',
+    image_gen: '16+ GB',
+    endpoint: '24+ GB',
+    batch: '16+ GB',
+    custom: '16+ GB',
+  };
+  return defaults[workloadType] || '16+ GB';
+}
+
+function estimateRuntimeMinutes(workloadType) {
+  if (workloadType === 'endpoint') return null; // runs until stopped, not a fixed job
+  const defaults = {
+    training: 120,
+    image_gen: 20,
+    batch: 30,
+    custom: 30,
+  };
+  return defaults[workloadType] ?? 30;
+}
+
+// ── Entry-point + workload-type inference ────────────────────────────────
+
+function pickEntrypoint(rootDir, allFiles) {
+  const relTop = allFiles
+    .filter(f => path.dirname(f) === rootDir)
+    .map(f => path.basename(f));
+
+  for (const candidate of ENTRYPOINT_CANDIDATES) {
+    if (relTop.includes(candidate)) {
+      return { file: candidate, confidenceBoost: 2 };
+    }
+  }
+  // Fall back to *any* single top-level .py/.js file if there's exactly one —
+  // common for "plain script" projects with no conventional entry-point name.
+  const topScripts = relTop.filter(f => /\.(py|js)$/.test(f));
+  if (topScripts.length === 1) {
+    return { file: topScripts[0], confidenceBoost: 1 };
+  }
+  return null;
+}
+
+function classifyWorkload({ entrypointText, hasWorkflowJson, hasDockerfile, hasTrainSignal, hasServeSignal, hasHandlerSignal, ports }) {
+  const signals = [];
+  let type = 'custom';
+  let score = 0;
+
+  if (hasHandlerSignal) {
+    signals.push('serverless-style handler function detected');
+    type = 'endpoint';
+    score += 2;
+  }
+  if (hasServeSignal || ports.length > 0) {
+    signals.push(ports.length > 0 ? `listens on port ${ports[0]}` : 'starts an HTTP server');
+    type = 'endpoint';
+    score += 2;
+  }
+  if (hasTrainSignal) {
+    signals.push('training/fine-tuning loop detected');
+    type = 'training';
+    score += 2;
+  }
+  if (hasWorkflowJson) {
+    signals.push('image-generation workflow file detected');
+    if (type === 'custom') type = 'image_gen';
+    score += 2;
+  }
+  if (hasDockerfile) {
+    signals.push('Dockerfile present');
+    score += 1;
+  }
+  if (/for\s+\w+\s+in\s+.*(os\.listdir|glob\(|Path\(.*\)\.iterdir)/.test(entrypointText || '')) {
+    signals.push('iterates over an input directory');
+    if (type === 'custom') type = 'batch';
+    score += 1;
+  }
+
+  return { type, score, signals };
+}
+
+/**
+ * Detect the shape of a GPU workload from a local project directory.
+ * Returns a plain object describing what was found — never throws for a
+ * missing/empty directory, so callers can always render a report.
+ */
+export function detectWorkload(dirPath) {
+  const rootDir = path.resolve(dirPath);
+  if (!fs.existsSync(rootDir) || !fs.statSync(rootDir).isDirectory()) {
+    return {
+      rootDir,
+      workloadType: 'custom',
+      confidence: 'low',
+      command: null,
+      image: null,
+      dockerfile: null,
+      requirements: [],
+      models: [],
+      inputs: [],
+      outputs: [],
+      checkpoints: [],
+      ports: [],
+      healthPath: null,
+      vram: '16+ GB',
+      runtimeEstimateMinutes: 30,
+      cacheableAssets: [],
+      signals: [],
+      error: 'directory not found',
+    };
+  }
+
+  const allFiles = walk(rootDir);
+
+  const dockerfilePath = allFiles.find(f => path.basename(f) === 'Dockerfile' && path.dirname(f) === rootDir);
+  const dockerfileText = dockerfilePath ? safeReadText(dockerfilePath) : '';
+
+  const requirements = REQUIREMENTS_FILES.filter(name =>
+    allFiles.some(f => path.basename(f) === name && path.dirname(f) === rootDir));
+
+  const workflowJson = allFiles.find(f =>
+    /workflow.*\.json$/i.test(path.basename(f)) && path.dirname(f) === rootDir);
+
+  const entry = pickEntrypoint(rootDir, allFiles);
+  const entrypointText = entry ? safeReadText(path.join(rootDir, entry.file)) : '';
+  const combinedText = entrypointText + '\n' + dockerfileText;
+
+  const hasServeSignal = /(uvicorn|fastapi|flask|app\.run\(|vllm\s+serve|VLLM|litserve|gradio|\.listen\()/i.test(combinedText);
+  const hasHandlerSignal = /(runpod\.serverless\.start|def\s+handler\s*\(|exports\.handler\s*=)/i.test(combinedText);
+  const hasTrainSignal = /(\.backward\(\)|optimizer\.step\(|Trainer\(|axolotl|lora|qlora|peft|accelerate|kohya)/i.test(combinedText) ||
+    (entry && /train|finetune/i.test(entry.file));
+  const ports = detectPorts([dockerfilePath, entry ? path.join(rootDir, entry.file) : null].filter(Boolean));
+
+  const { type: workloadType, score, signals } = classifyWorkload({
+    entrypointText: combinedText,
+    hasWorkflowJson: Boolean(workflowJson),
+    hasDockerfile: Boolean(dockerfilePath),
+    hasTrainSignal,
+    hasServeSignal,
+    hasHandlerSignal,
+    ports,
+  });
+
+  const models = detectModelRefs([
+    ...(entry ? [path.join(rootDir, entry.file)] : []),
+    ...(workflowJson ? [workflowJson] : []),
+    ...allFiles.filter(f => /\.ya?ml$/i.test(f) && path.dirname(f) === rootDir),
+  ]);
+
+  const inputs = listDirsMatching(allFiles, rootDir, INPUT_DIR_NAMES);
+  const outputs = listDirsMatching(allFiles, rootDir, OUTPUT_DIR_NAMES);
+  const checkpoints = listDirsMatching(allFiles, rootDir, CHECKPOINT_DIR_NAMES);
+  const modelDirs = listDirsMatching(allFiles, rootDir, MODEL_DIR_NAMES);
+
+  let command = null;
+  if (entry) {
+    if (/\.py$/.test(entry.file)) command = `python ${entry.file}`;
+    else if (/\.js$/.test(entry.file)) command = `node ${entry.file}`;
+  } else if (workflowJson) {
+    command = `python main.py --workflow ${path.basename(workflowJson)}`;
+  }
+
+  let confidenceScore = score + (entry ? entry.confidenceBoost : 0) + (requirements.length > 0 ? 1 : 0);
+  let confidence = 'low';
+  if (confidenceScore >= 4) confidence = 'high';
+  else if (confidenceScore >= 2) confidence = 'medium';
+
+  if (entry) signals.push(`entry point: ${entry.file}`);
+  if (requirements.length) signals.push(`dependency manifest: ${requirements.join(', ')}`);
+  if (!entry && !workflowJson) signals.push('no recognizable entry point — command must be supplied');
+
+  const healthPath = hasHandlerSignal ? null : (hasServeSignal ? '/health' : null);
+
+  const cacheableAssets = [
+    ...modelDirs,
+    ...(requirements.length ? requirements : []),
+  ];
+
+  return {
+    rootDir,
+    workloadType,
+    confidence,
+    command,
+    image: dockerfilePath ? null : undefined, // Dockerfile present → image is built from it, not picked
+    dockerfile: dockerfilePath ? path.relative(rootDir, dockerfilePath) : null,
+    requirements,
+    models,
+    inputs,
+    outputs,
+    checkpoints,
+    ports,
+    healthPath,
+    vram: estimateVramFromModelRefs(models, workloadType),
+    runtimeEstimateMinutes: estimateRuntimeMinutes(workloadType),
+    cacheableAssets,
+    signals,
+  };
+}
+
+/** Human label for a workload type — used by both `detect` and `run` reports. */
+export function workloadTypeLabel(type) {
+  return {
+    endpoint: 'endpoint',
+    training: 'training',
+    image_gen: 'batch (image generation)',
+    batch: 'batch',
+    custom: 'custom GPU job',
+  }[type] || 'custom GPU job';
+}