domainstorm 0.2.1 → 0.2.3

package/README.md

@@ -19,7 +19,7 @@ It is built for AI and agent products where naming cycles happen fast and every
 ## Install
 
 ```bash
-npm i -g domainstorm
+npm i -g domainstorm@latest
 ```
 
 Run instantly without global install:
@@ -28,26 +28,41 @@ Run instantly without global install:
 npx --yes domainstorm --help
 ```
 
+Update to latest:
+
+```bash
+npm update -g domainstorm
+```
+
 ## Quick Wins
 
 Brainstorm + check + return only likely available:
 
 ```bash
-domainstorm --brainstorm "agent orchestration" "mcp broker" --tld md --server whois.nic.md --only-available
+domainstorm --brainstorm "agent orchestration" "mcp broker" --tld md --server whois.nic.md --dns-prefilter --only-available --table
 ```
 
 Check exact domains:
 
 ```bash
-domainstorm agentmesh.ai agentmesh.com agentmesh.md
+domainstorm broker.md --server whois.nic.md --dns-prefilter
 ```
 
+Default output is plain English (for example: `✅ broker.md is available.`).
+Use `--table` if you want a structured table view.
+
 Check from file and export CSV:
 
 ```bash
 domainstorm --input domains.txt --output /tmp/domainstorm.csv
 ```
 
+Try immediately with the bundled candidate list:
+
+```bash
+domainstorm --input agent-candidates.txt --tld md --server whois.nic.md --only-available --table
+```
+
 ## Built For Agent Workflows
 
 Use Domainstorm when your coding/research agent needs to propose names and validate them in the same run.
@@ -56,6 +71,7 @@ Use Domainstorm when your coding/research agent needs to propose names and valid
 - Works with shell pipelines
 - No external AI API keys required
 - Easy to trigger in CI on release or branch workflows
+- No seed ideas? Ask your agent of choice (Codex, Claude, etc.) for seed phrases and pass them to `--brainstorm`
 
 Compatibility alias:
 
@@ -63,11 +79,29 @@ Compatibility alias:
 domain-check --help
 ```
 
+## Local Dev Test (npm)
+
+Run the current repo version without publishing:
+
+```bash
+npm run check
+npm link
+domainstorm --help
+domainstorm broker.md --table
+```
+
+Remove local link when done:
+
+```bash
+npm unlink -g domainstorm
+```
+
 ## Example Output
 
 ```txt
-agentmesh.md    likely_available    availability_pattern_match    low    story=Keyword + product framing
-agentops.md     registered          registration_pattern_match    low    story=Keyword + product framing
+✅ broker.md is available.
+❌ agentops.md is not available (already registered).
+Summary: ✅ 1 available, ❌ 1 taken, ⚠️ 0 unknown.
 ```
 
 Output columns:
@@ -75,6 +109,7 @@ Output columns:
 - `domain`
 - `status` (`registered`, `likely_available`, `unknown`)
 - `reason`
+- `state` (registry/DNS state when available)
 - `legal_risk` (`low`, `high_tm_risk`)
 - `story` (brainstorm narrative tag)
 - `error`
@@ -83,10 +118,13 @@ Output columns:
 
 - `--brainstorm` / `--storm`
 - `--max-suggestions <n>` (default: `120`)
+- `--table`
+- `--plain`
 - `--input <file>`
 - `--output <file>`
 - `--tld <tld>` (default: `md`)
 - `--server <whois-host>`
+- `--dns-prefilter`
 - `--only-available`
 - `--concurrency <n>`
 - `--timeout-ms <n>`
@@ -132,8 +170,18 @@ npm login
 npm publish --access public
 ```
 
+If local provenance is unsupported in your shell/provider, use:
+
+```bash
+npm publish --access public --provenance=false
+```
+
 ## Notes
 
 - WHOIS formats vary by registry; treat `likely_available` as a pre-check, not final registrar checkout.
 - Registries can rate-limit bulk lookups; retry `unknown` rows after cooldown.
+- Domainstorm includes registry adapters for `.md`, `.com`, `.org`, and `.ai` to improve state parsing.
+- Domainstorm auto-throttles WHOIS to concurrency `2` across TLDs (override with `--concurrency`).
+- For `.md`, `Domain state` is parsed explicitly (`Inactive`, `OK`, `OK Delegated`, and no-match states).
+- `--dns-prefilter` runs DNS first and marks resolving domains as taken before WHOIS (faster and lighter on WHOIS quota).
 - Install `whois` locally (`brew install whois` on macOS).

package/check-domains.mjs

@@ -5,9 +5,11 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 
 const DEFAULT_CONCURRENCY = 6;
+const SAFE_WHOIS_CONCURRENCY = 2;
 const DEFAULT_TIMEOUT_MS = 12000;
 const DEFAULT_TLD = "md";
 const DEFAULT_MAX_SUGGESTIONS = 120;
+const MD_WHOIS_SERVER = "whois.nic.md";
 const AVAILABILITY_PATTERNS = [
   "no match for",
   "not found",
@@ -75,59 +77,6 @@ const STOP_WORDS = new Set([
   "agents",
 ]);
 
-const DEFAULT_STORM_SEEDS = [
-  "agent",
-  "mcp",
-  "ai",
-  "broker",
-  "router",
-  "runtime",
-  "ops",
-  "stack",
-  "forge",
-  "mesh",
-  "pilot",
-  "flow",
-];
-
-const STORM_SUFFIXES = [
-  "storm",
-  "ops",
-  "hub",
-  "mesh",
-  "forge",
-  "stack",
-  "pilot",
-  "route",
-  "router",
-  "broker",
-  "runtime",
-  "engine",
-  "works",
-  "cloud",
-  "grid",
-  "terminal",
-  "dock",
-  "labs",
-  "studio",
-];
-
-const STORM_PREFIXES = [
-  "agent",
-  "ai",
-  "mcp",
-  "task",
-  "flow",
-  "auto",
-  "tool",
-  "prompt",
-  "context",
-  "trace",
-  "guard",
-  "secure",
-  "fleet",
-];
-
 // Small, non-authoritative heuristic list for quick legal-risk triage.
 const TRADEMARK_KEYWORDS = [
   "openai",
@@ -165,16 +114,22 @@ function printUsage() {
       "  --output <file>        Optional CSV output path",
       "  --tld <tld>            Default TLD for bare labels (default: md)",
       "  --server <host>        Optional WHOIS server (ex: whois.nic.md)",
-      "  --concurrency <n>      Parallel WHOIS requests (default: 6)",
+      "  --concurrency <n>      Parallel WHOIS requests (default: 6, auto-throttled to 2 unless set)",
       "  --timeout-ms <n>       WHOIS timeout per domain (default: 12000)",
+      "  --dns-prefilter        Run DNS pre-check (A/AAAA/CNAME); skip WHOIS for resolving domains",
       "  --brainstorm           Generate domain ideas from seeds, then check availability",
       "  --max-suggestions <n>  Max brainstormed candidates (default: 120)",
+      "  --table                Render results in a readable terminal table",
+      "  --plain                Emit machine-friendly TSV output",
       "  --only-available       Print only likely available domains",
       "  --raw                  Include WHOIS snippet in console output",
       "  --help                 Show this help",
       "",
       "Notes:",
       "  - Labels without a dot are auto-converted to <label>.<tld>",
+      "  - WHOIS is auto-throttled to concurrency=2 unless you set --concurrency",
+      "  - Brainstorm mode uses your seed words only (no hardcoded keyword packs)",
+      "  - No seed ideas? Ask your agent (Codex, Claude, etc.) and pass them to --brainstorm",
       "  - WHOIS-based checks are heuristic; always confirm at registrar checkout",
     ].join("\n"),
   );
@@ -185,11 +140,15 @@ function parseArgs(argv) {
     input: null,
     output: null,
     concurrency: DEFAULT_CONCURRENCY,
+    concurrencyExplicit: false,
     timeoutMs: DEFAULT_TIMEOUT_MS,
     tld: DEFAULT_TLD,
     server: null,
+    dnsPrefilter: false,
     brainstorm: false,
     maxSuggestions: DEFAULT_MAX_SUGGESTIONS,
+    table: false,
+    plain: false,
     onlyAvailable: false,
     raw: false,
     labels: [],
@@ -209,6 +168,7 @@ function parseArgs(argv) {
       case "--concurrency":
       case "-c":
         options.concurrency = Number.parseInt(argv[++i], 10);
+        options.concurrencyExplicit = true;
         break;
       case "--tld":
         options.tld = argv[++i];
@@ -219,6 +179,9 @@ function parseArgs(argv) {
       case "--timeout-ms":
         options.timeoutMs = Number.parseInt(argv[++i], 10);
         break;
+      case "--dns-prefilter":
+        options.dnsPrefilter = true;
+        break;
       case "--brainstorm":
       case "--storm":
         options.brainstorm = true;
@@ -226,6 +189,12 @@ function parseArgs(argv) {
       case "--max-suggestions":
         options.maxSuggestions = Number.parseInt(argv[++i], 10);
         break;
+      case "--table":
+        options.table = true;
+        break;
+      case "--plain":
+        options.plain = true;
+        break;
       case "--only-available":
         options.onlyAvailable = true;
         break;
@@ -249,7 +218,9 @@ function parseArgs(argv) {
   }
 
   if (!options.input && options.labels.length === 0 && !options.brainstorm) {
-    throw new Error("Provide --input <file>, one/more labels/domains, or use --brainstorm.");
+    throw new Error(
+      "Provide --input <file>, one/more labels/domains, or use --brainstorm. Tip: ask your agent (Codex, Claude, etc.) for seed phrases.",
+    );
   }
   if (!Number.isInteger(options.concurrency) || options.concurrency < 1 || options.concurrency > 50) {
     throw new Error("--concurrency must be an integer between 1 and 50.");
@@ -349,7 +320,12 @@ function tokenizeSeeds(rawValues) {
 
 function brainstormCandidates(rawSeeds, maxSuggestions) {
   const seedTokens = tokenizeSeeds(rawSeeds);
-  const seedPool = Array.from(new Set([...seedTokens, ...DEFAULT_STORM_SEEDS])).slice(0, 24);
+  if (seedTokens.length === 0) {
+    throw new Error(
+      "Brainstorm mode needs seed words. Ask your agent of choice (Codex, Claude, etc.) for naming seeds, then run: --brainstorm \"seed one\" \"seed two\"",
+    );
+  }
+  const seedPool = Array.from(new Set(seedTokens)).slice(0, 24);
   const scored = new Map();
 
   function add(label, story, bonus = 0) {
@@ -368,24 +344,67 @@ function brainstormCandidates(rawSeeds, maxSuggestions) {
     }
   }
 
+  function shortForm(token) {
+    if (token.length < 5) {
+      return token;
+    }
+    const withoutVowels = token[0] + token.slice(1).replace(/[aeiou]/g, "");
+    if (withoutVowels.length >= 3 && withoutVowels.length < token.length) {
+      return withoutVowels;
+    }
+    return token;
+  }
+
+  const formsBySeed = new Map();
   for (const seed of seedPool) {
-    add(seed, "Keyword brand");
-    for (const suffix of STORM_SUFFIXES) {
-      add(`${seed}${suffix}`, "Keyword + product framing", seed.length < 8 ? 25 : 10);
+    const forms = new Set([seed, shortForm(seed)]);
+    if (seed.length > 8) {
+      forms.add(seed.slice(0, 7));
     }
-    for (const prefix of STORM_PREFIXES) {
-      add(`${prefix}${seed}`, "Platform + keyword framing", 10);
+    formsBySeed.set(seed, Array.from(forms));
+  }
+
+  for (const seed of seedPool) {
+    for (const form of formsBySeed.get(seed)) {
+      add(form, form === seed ? "Seed keyword" : "Compressed variant", form === seed ? 18 : 10);
     }
   }
 
   for (let i = 0; i < seedPool.length; i += 1) {
-    for (let j = i + 1; j < seedPool.length; j += 1) {
-      const a = seedPool[i];
-      const b = seedPool[j];
-      add(`${a}${b}`, "Two-keyword compound", 20);
-      add(`${b}${a}`, "Two-keyword compound", 20);
-      add(`${a}${b}hq`, "Company-style compound", 10);
-      add(`${a}${b}labs`, "Innovation-style compound", 8);
+    for (let j = 0; j < seedPool.length; j += 1) {
+      if (i === j) {
+        continue;
+      }
+      const aForms = formsBySeed.get(seedPool[i]);
+      const bForms = formsBySeed.get(seedPool[j]);
+      for (const a of aForms) {
+        for (const b of bForms) {
+          add(`${a}${b}`, "Two-seed compound", 20);
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < seedPool.length; i += 1) {
+    for (let j = 0; j < seedPool.length; j += 1) {
+      for (let k = 0; k < seedPool.length; k += 1) {
+        if (i === j || j === k || i === k) {
+          continue;
+        }
+        const a = formsBySeed.get(seedPool[i])[0];
+        const b = formsBySeed.get(seedPool[j])[0];
+        const c = formsBySeed.get(seedPool[k])[0];
+        add(`${a}${b}${c}`, "Three-seed compound", 10);
+      }
+    }
+  }
+
+  const acronym = seedPool.map((token) => token[0]).join("");
+  if (acronym.length >= 3) {
+    add(acronym, "Seed acronym", 16);
+    for (const seed of seedPool) {
+      add(`${acronym}${seed}`, "Acronym + seed", 12);
+      add(`${seed}${acronym}`, "Seed + acronym", 12);
     }
   }
 
@@ -396,11 +415,102 @@ function brainstormCandidates(rawSeeds, maxSuggestions) {
   return {
     labels: sorted.map((item) => item.label),
     storyByLabel: new Map(sorted.map((item) => [item.label, item.story])),
-    usedSeeds: seedTokens.length > 0 ? Array.from(new Set(seedTokens)) : DEFAULT_STORM_SEEDS,
+    usedSeeds: seedPool,
   };
 }
 
-function classifyWhois(raw) {
+function isMdDomain(domain) {
+  return domain.endsWith(".md");
+}
+
+function getDomainTld(domain) {
+  const idx = domain.lastIndexOf(".");
+  if (idx < 0 || idx === domain.length - 1) {
+    return "";
+  }
+  return domain.slice(idx + 1).toLowerCase();
+}
+
+function shouldUseMdRules(domain, server) {
+  if (isMdDomain(domain)) {
+    return true;
+  }
+  if (!server) {
+    return false;
+  }
+  return server === MD_WHOIS_SERVER || server.endsWith(".nic.md") || server.endsWith(".md");
+}
+
+function classifyMdWhois(raw) {
+  const text = raw.toLowerCase();
+  if (
+    text.includes("no entries found [ no match for ]") ||
+    (text.includes("no entries found") && text.includes("no match for"))
+  ) {
+    return {
+      status: "likely_available",
+      reason: "md_no_match",
+      state: "No match",
+    };
+  }
+
+  const stateMatch = raw.match(/domain state:\s*([^\r\n]+)/i);
+  if (!stateMatch) {
+    return null;
+  }
+
+  const state = stateMatch[1].trim();
+  const lower = state.toLowerCase();
+  if (lower.includes("inactive")) {
+    return { status: "registered", reason: "md_state_inactive", state };
+  }
+  if (lower.includes("ok delegated")) {
+    return { status: "registered", reason: "md_state_ok_delegated", state };
+  }
+  if (lower === "ok" || lower.startsWith("ok ")) {
+    return { status: "registered", reason: "md_state_ok", state };
+  }
+  return { status: "registered", reason: "md_state_registered", state };
+}
+
+function cleanDomainStatus(value) {
+  return value
+    .replace(/\s+https?:\/\/\S+$/i, "")
+    .replace(/\s+\(https?:\/\/\S+\)$/i, "")
+    .trim();
+}
+
+function classifyComOrgAiWhois(raw, domain) {
+  const tld = getDomainTld(domain);
+  if (!["com", "org", "ai"].includes(tld)) {
+    return null;
+  }
+
+  const text = raw.toLowerCase();
+  if (tld === "com" && text.includes('no match for domain "')) {
+    return { status: "likely_available", reason: "com_no_match", state: "No match" };
+  }
+  if ((tld === "org" || tld === "ai") && text.includes("domain not found")) {
+    return { status: "likely_available", reason: `${tld}_domain_not_found`, state: "No match" };
+  }
+
+  const statusMatch = raw.match(/Domain Status:\s*([^\r\n]+)/i);
+  if (statusMatch) {
+    return {
+      status: "registered",
+      reason: `${tld}_domain_status`,
+      state: cleanDomainStatus(statusMatch[1]),
+    };
+  }
+
+  if (/Domain Name:\s*[^\r\n]+/i.test(raw) || /Registry Domain ID:\s*[^\r\n]+/i.test(raw)) {
+    return { status: "registered", reason: `${tld}_registered`, state: "" };
+  }
+
+  return null;
+}
+
+function classifyWhois(raw, domain, server) {
   const text = raw.toLowerCase();
   if (!text.trim()) {
     return { status: "unknown", reason: "empty_whois_response" };
@@ -411,6 +521,16 @@ function classifyWhois(raw) {
   if (RATE_LIMIT_PATTERNS.some((p) => text.includes(p))) {
     return { status: "unknown", reason: "rate_limited_or_blocked" };
   }
+  if (shouldUseMdRules(domain, server)) {
+    const md = classifyMdWhois(raw);
+    if (md) {
+      return md;
+    }
+  }
+  const common = classifyComOrgAiWhois(raw, domain);
+  if (common) {
+    return common;
+  }
   if (AVAILABILITY_PATTERNS.some((p) => text.includes(p))) {
     return { status: "likely_available", reason: "availability_pattern_match" };
   }
@@ -420,6 +540,75 @@ function classifyWhois(raw) {
   return { status: "unknown", reason: "unrecognized_whois_format" };
 }
 
+function runDigType(domain, type, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn("dig", ["+short", domain, type], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let done = false;
+    const timer = setTimeout(() => {
+      if (done) {
+        return;
+      }
+      done = true;
+      child.kill("SIGKILL");
+      resolve({ values: [], error: `dig ${type} timeout` });
+    }, Math.min(timeoutMs, 5000));
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      resolve({ values: [], error: err.message });
+    });
+    child.on("close", () => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      const values = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+      resolve({ values, error: stderr.trim() || null });
+    });
+  });
+}
+
+async function runDnsPrefilter(domain, timeoutMs) {
+  const a = await runDigType(domain, "A", timeoutMs);
+  if (a.values.length > 0) {
+    return { domain, resolves: true, recordType: "A", values: a.values, error: null };
+  }
+  const aaaa = await runDigType(domain, "AAAA", timeoutMs);
+  if (aaaa.values.length > 0) {
+    return { domain, resolves: true, recordType: "AAAA", values: aaaa.values, error: null };
+  }
+  const cname = await runDigType(domain, "CNAME", timeoutMs);
+  if (cname.values.length > 0) {
+    return { domain, resolves: true, recordType: "CNAME", values: cname.values, error: null };
+  }
+  return {
+    domain,
+    resolves: false,
+    recordType: "",
+    values: [],
+    error: a.error || aaaa.error || cname.error || null,
+  };
+}
+
 function runWhois(domain, timeoutMs, server) {
   return new Promise((resolve) => {
     const args = server ? ["-h", server, domain] : [domain];
@@ -474,12 +663,13 @@ function runWhois(domain, timeoutMs, server) {
       done = true;
       clearTimeout(timer);
       const merged = [stdout, stderr].filter(Boolean).join("\n");
-      const classification = classifyWhois(merged);
+      const classification = classifyWhois(merged, domain, server);
       const stderrText = stderr.trim();
       resolve({
         domain,
         status: classification.status,
         reason: classification.reason,
+        state: classification.state ?? "",
         raw: merged.trim(),
         error: classification.reason === "whois_lookup_failed" ? stderrText || "WHOIS lookup failed" : null,
       });
@@ -519,7 +709,7 @@ async function maybeWriteCsv(results, outputPath) {
   if (!outputPath) {
     return;
   }
-  const header = ["domain", "status", "reason", "legal_risk", "story", "error"];
+  const header = ["domain", "status", "reason", "state", "legal_risk", "story", "error"];
   const lines = [header.join(",")];
   for (const row of results) {
     lines.push(
@@ -527,6 +717,7 @@ async function maybeWriteCsv(results, outputPath) {
         row.domain,
         row.status,
         row.reason,
+        row.state ?? "",
         row.legalRisk,
         row.story ?? "",
         row.error ?? "",
@@ -558,6 +749,150 @@ function snippet(raw) {
   return raw.replace(/\s+/g, " ").slice(0, 120);
 }
 
+function verdictForStatus(status) {
+  switch (status) {
+    case "likely_available":
+      return "✅ AVAILABLE";
+    case "registered":
+      return "❌ TAKEN";
+    default:
+      return "⚠️ UNKNOWN";
+  }
+}
+
+function sentenceForRow(row) {
+  if (row.status === "likely_available") {
+    return `✅ ${row.domain} is available.`;
+  }
+  if (row.status === "registered") {
+    if (row.reason === "dns_resolves_prefilter") {
+      return `❌ ${row.domain} is not available (DNS resolves).`;
+    }
+    if (row.reason === "md_state_inactive") {
+      return `❌ ${row.domain} is not available (registered, inactive).`;
+    }
+    if (row.reason === "md_state_ok") {
+      return `❌ ${row.domain} is not available (registered, state: OK).`;
+    }
+    if (row.reason === "md_state_ok_delegated") {
+      return `❌ ${row.domain} is not available (registered, state: OK Delegated).`;
+    }
+    if (row.state) {
+      return `❌ ${row.domain} is not available (registered, state: ${row.state}).`;
+    }
+    return `❌ ${row.domain} is not available (already registered).`;
+  }
+  return `⚠️ ${row.domain} availability is unknown (whois could not confirm).`;
+}
+
+function toDisplayRow(row, options) {
+  return {
+    verdict: verdictForStatus(row.status),
+    domain: row.domain,
+    whois: row.status,
+    state: row.state ?? "",
+    reason: row.reason,
+    risk: row.legalRisk,
+    story: row.story ?? "",
+    error: row.error ?? "",
+    raw: options.raw ? snippet(row.raw) : "",
+  };
+}
+
+function truncateCell(value, maxWidth) {
+  const text = String(value ?? "");
+  if (text.length <= maxWidth) {
+    return text;
+  }
+  if (maxWidth <= 1) {
+    return text.slice(0, maxWidth);
+  }
+  return `${text.slice(0, maxWidth - 1)}…`;
+}
+
+function printTable(rows, options) {
+  const displayRows = rows.map((row) => toDisplayRow(row, options));
+  const hasState = displayRows.some((row) => row.state);
+  const hasStory = displayRows.some((row) => row.story);
+  const hasError = displayRows.some((row) => row.error);
+  const columns = [
+    { key: "verdict", label: "Verdict", maxWidth: 14 },
+    { key: "domain", label: "Domain", maxWidth: 44 },
+    { key: "whois", label: "Whois", maxWidth: 18 },
+    ...(hasState ? [{ key: "state", label: "State", maxWidth: 22 }] : []),
+    { key: "reason", label: "Reason", maxWidth: 34 },
+    { key: "risk", label: "Risk", maxWidth: 14 },
+    ...(hasStory ? [{ key: "story", label: "Story", maxWidth: 36 }] : []),
+    ...(hasError ? [{ key: "error", label: "Error", maxWidth: 44 }] : []),
+    ...(options.raw ? [{ key: "raw", label: "Raw", maxWidth: 44 }] : []),
+  ];
+
+  const widths = new Map();
+  for (const col of columns) {
+    const maxValueLen = displayRows.reduce((max, row) => Math.max(max, String(row[col.key] ?? "").length), 0);
+    widths.set(col.key, Math.min(Math.max(col.label.length, maxValueLen), col.maxWidth));
+  }
+
+  const formatCell = (value, width) => truncateCell(value, width).padEnd(width, " ");
+  const header = columns.map((col) => formatCell(col.label, widths.get(col.key))).join(" | ");
+  const separator = columns.map((col) => "-".repeat(widths.get(col.key))).join("-+-");
+  console.log(header);
+  console.log(separator);
+  for (const row of displayRows) {
+    const line = columns.map((col) => formatCell(row[col.key], widths.get(col.key))).join(" | ");
+    console.log(line);
+  }
+}
+
+function printDecoratedResults(rows, options) {
+  const title = " DOMAINSTORM RESULTS ";
+  const border = "=".repeat(Math.max(68, title.length + 8));
+  console.log(border);
+  console.log(title);
+  console.log(border);
+  if (rows.length === 0) {
+    console.log("No domains matched your filters.");
+    return;
+  }
+  printTable(rows, options);
+  if (rows.length === 1) {
+    const row = rows[0];
+    console.log("");
+    console.log(`Result: ${row.domain} is ${verdictForStatus(row.status)}.`);
+  }
+}
+
+function printNarrativeResults(rows, options) {
+  if (rows.length === 0) {
+    console.log("No domains matched your filters.");
+    return;
+  }
+
+  for (const row of rows) {
+    console.log(sentenceForRow(row));
+    if (row.status === "unknown" || row.error) {
+      let detail = `  reason: ${row.reason}`;
+      if (row.error) {
+        detail += ` | error: ${row.error}`;
+      }
+      console.log(detail);
+    }
+    if (row.story) {
+      console.log(`  story: ${row.story}`);
+    }
+    if (options.raw) {
+      console.log(`  raw: ${snippet(row.raw)}`);
+    }
+  }
+}
+
+function shouldAutoThrottleWhois(domains) {
+  if (domains.length === 0) {
+    return false;
+  }
+  return true;
+}
+
 async function main() {
   const options = parseArgs(process.argv.slice(2));
   let rawLabels = await loadLabels(options);
@@ -592,11 +927,56 @@ async function main() {
     throw new Error("No valid domains found after normalization.");
   }
 
+  const effectiveConcurrency =
+    !options.concurrencyExplicit && shouldAutoThrottleWhois(domains)
+      ? Math.min(options.concurrency, SAFE_WHOIS_CONCURRENCY)
+      : options.concurrency;
+
+  if (effectiveConcurrency !== options.concurrency) {
+    console.error(
+      `Auto-throttle: using concurrency=${effectiveConcurrency} for WHOIS (override with --concurrency).`,
+    );
+  }
+
   const serverLabel = options.server ? `server=${options.server}` : "server=auto";
-  console.error(`Checking ${domains.length} domain(s) (${serverLabel}) with concurrency=${options.concurrency}`);
+  console.error(`Checking ${domains.length} domain(s) (${serverLabel}) with concurrency=${effectiveConcurrency}`);
+
+  const dnsPrefilterResults = [];
+  let whoisTargets = domains;
+  if (options.dnsPrefilter) {
+    const dnsConcurrency = options.concurrencyExplicit ? options.concurrency : Math.min(20, domains.length || 1);
+    const dnsChecks = await mapLimit(domains, dnsConcurrency, async (domain) =>
+      runDnsPrefilter(domain, options.timeoutMs),
+    );
+
+    const dnsTaken = dnsChecks.filter((item) => item.resolves);
+    if (dnsTaken.length > 0) {
+      console.error(`DNS prefilter: ${dnsTaken.length} domain(s) resolve; marked as taken without WHOIS.`);
+    }
+
+    for (const item of dnsTaken) {
+      dnsPrefilterResults.push({
+        domain: item.domain,
+        status: "registered",
+        reason: "dns_resolves_prefilter",
+        state: `DNS ${item.recordType}`,
+        raw: "",
+        error: null,
+      });
+    }
+    whoisTargets = dnsChecks.filter((item) => !item.resolves).map((item) => item.domain);
+  }
+
+  const whoisResults = await mapLimit(whoisTargets, effectiveConcurrency, async (domain) =>
+    runWhois(domain, options.timeoutMs, options.server),
+  );
 
-  const checked = await mapLimit(domains, options.concurrency, async (domain) => {
-    const result = await runWhois(domain, options.timeoutMs, options.server);
+  const mergedByDomain = new Map();
+  for (const result of [...dnsPrefilterResults, ...whoisResults]) {
+    mergedByDomain.set(result.domain, result);
+  }
+  const checked = domains.map((domain) => {
+    const result = mergedByDomain.get(domain);
     const label = domain.slice(0, domain.lastIndexOf("."));
     return {
       ...result,
@@ -609,26 +989,33 @@ async function main() {
     ? checked.filter((row) => row.status === "likely_available")
     : checked;
 
-  for (const row of filtered) {
-    let line = `${row.domain}\t${row.status}\t${row.reason}\t${row.legalRisk}`;
-    if (row.story) {
-      line += `\tstory=${row.story}`;
-    }
-    if (row.error) {
-      line += `\terror=${row.error}`;
-    }
-    if (options.raw) {
-      line += `\t${snippet(row.raw)}`;
+  if (options.plain) {
+    for (const row of filtered) {
+      let line = `${row.domain}\t${row.status}\t${row.reason}\t${row.legalRisk}`;
+      if (row.state) {
+        line += `\tstate=${row.state}`;
+      }
+      if (row.story) {
+        line += `\tstory=${row.story}`;
+      }
+      if (row.error) {
+        line += `\terror=${row.error}`;
+      }
+      if (options.raw) {
+        line += `\t${snippet(row.raw)}`;
+      }
+      console.log(line);
     }
-    console.log(line);
+  } else if (options.table) {
+    printDecoratedResults(filtered, options);
+  } else {
+    printNarrativeResults(filtered, options);
   }
 
   await maybeWriteCsv(checked, options.output);
 
   const counts = summarize(checked);
-  console.error(
-    `Summary: likely_available=${counts.likelyAvailable}, registered=${counts.registered}, unknown=${counts.unknown}`,
-  );
+  console.error(`Summary: ✅ ${counts.likelyAvailable} available, ❌ ${counts.registered} taken, ⚠️ ${counts.unknown} unknown.`);
   if (options.output) {
     console.error(`CSV written: ${path.resolve(options.output)}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domainstorm",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Brainstorm and check domain names in one command.",
   "repository": {
     "type": "git",