@namingsignal/cli 0.2.0

package/dist/core/brief.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileBrief = compileBrief;
+exports.reconcileBriefUncertainties = reconcileBriefUncertainties;
+const CHANNELS = [
+    ["developer agents", /\b(?:codex|claude code|cursor|mcp|developer agents?)\b/i],
+    ["word of mouth", /\b(?:word[- ]of[- ]mouth|referrals?|spoken|podcasts?)\b/i],
+    ["creator video", /\b(?:instagram|youtube|tiktok|reels|shorts|creator(?:s| marketing)?|ugc|video)\b/i],
+    ["app stores", /\b(?:app store|google play|aso|ios|android)\b/i],
+    ["search", /\b(?:seo|organic search|search traffic|content marketing)\b/i],
+    ["paid acquisition", /\b(?:paid ads?|performance marketing|paid acquisition)\b/i],
+    ["sales", /\b(?:sales-led|enterprise sales|outbound|sales team)\b/i],
+    ["communities", /\b(?:community|communities|product hunt|hacker news|reddit)\b/i],
+];
+const TONES = [
+    "calm",
+    "capable",
+    "clear",
+    "rhythmic",
+    "memorable",
+    "trustworthy",
+    "developer-native",
+    "technical",
+    "friendly",
+    "premium",
+    "confident",
+    "playful",
+    "serious",
+    "private",
+    "bold",
+    "minimal",
+    "approachable",
+    "warm",
+    "crafted",
+    "elegant",
+];
+const NAMING_GUIDANCE = /^(?:(?:the )?(?:name|brand|names)\s+(?:should|must|needs? to)|(?:name|brand)\s+guidance\b)/i;
+const STANDARD_UNCERTAINTIES = {
+    product: "A meaningful product description could not be inferred; add a few descriptive words.",
+    primaryUser: "Primary user was not explicit; confirm who should love the first release.",
+    pain: "The current pain or fragmented workflow was not explicit.",
+    outcome: "The promised user outcome needs confirmation.",
+    mechanism: "The differentiating mechanism needs confirmation.",
+    channels: "Acquisition channel is unknown; spoken-name weighting may change.",
+    future: "Future product scope is unknown; confirm how broad the brand must remain.",
+    domains: "Preferred TLD and domain acquisition budget are unknown.",
+    tone: "Desired brand tone needs confirmation.",
+};
+const PLATFORMS = [
+    ["web", /\b(?:web(?:site| app)?|saas|browser|landing page)\b/i],
+    ["mobile", /\b(?:mobile|ios|android|app store)\b/i],
+    ["desktop", /\b(?:desktop|macos|windows|linux app)\b/i],
+    ["cli", /\b(?:cli|command line|terminal)\b/i],
+    ["api", /\bapi\b/i],
+    ["mcp", /\bmcp\b/i],
+    ["extension", /\b(?:browser|chrome|vscode) extension\b/i],
+];
+const INJECTION_LINE = /\b(?:ignore.{0,48}(?:instructions?|prompts?)|system message|developer message|jailbreak|reveal (?:the )?(?:prompt|secret)|do not follow)\b/i;
+const SECTION_FIELDS = [
+    ["product", /^(?:product|what it is|product description)$/i],
+    ["primaryUser", /^(?:primary user|target user|audience|customer|who it is for)$/i],
+    ["pain", /^(?:core )?(?:pain|problem|friction|current problem)$/i],
+    ["outcome", /^(?:outcome|promise|transformation|result|benefit)$/i],
+    ["mechanism", /^(?:mechanism(?: and differentiators)?|how it works|approach|unique mechanism|differentiators)$/i],
+    ["futureExpansion", /^(?:scope and expansion|future expansion|future scope|roadmap|long-term scope)$/i],
+    ["avoid", /^(?:avoid|do not use|names to avoid|banned roots|patterns to avoid)$/i],
+];
+function markdownSections(raw) {
+    const sections = [];
+    let heading = "";
+    let body = [];
+    const flush = () => {
+        if (heading && body.some((line) => line.trim()))
+            sections.push({ heading, body: body.join("\n").trim() });
+    };
+    for (const line of raw.normalize("NFKC").replace(/\r\n?/g, "\n").split("\n")) {
+        const match = line.match(/^\s{0,3}#{2,6}\s+(.+?)\s*#*\s*$/);
+        if (match) {
+            flush();
+            heading = compact(match[1], 100);
+            body = [];
+        }
+        else if (heading) {
+            body.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function sectionMap(raw) {
+    const mapped = {};
+    for (const section of markdownSections(raw)) {
+        const field = SECTION_FIELDS.find(([, pattern]) => pattern.test(section.heading))?.[0];
+        if (field && !mapped[field])
+            mapped[field] = section;
+    }
+    return mapped;
+}
+function sectionProse(section, maximum = 720) {
+    if (!section)
+        return "";
+    return compact(cleanMarkdown(section.body), maximum);
+}
+function sectionFirstSentence(section, maximum = 520) {
+    const prose = sectionProse(section, Math.max(maximum, 720));
+    return compact(usefulSentences(prose)[0] || prose, maximum);
+}
+function sectionBullets(section) {
+    if (!section)
+        return [];
+    const bullets = section.body
+        .split("\n")
+        .map((line) => line.match(/^\s*(?:[-*+] |\d+[.)] )(.+)$/)?.[1])
+        .map((line) => compact(line, 220))
+        .filter((line) => Boolean(line));
+    return [...new Set(bullets)].slice(0, 20);
+}
+function cleanMarkdown(input) {
+    return input
+        .normalize("NFKC")
+        .replace(/\r\n?/g, "\n")
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, " ")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/^\s{0,3}(?:#{1,6}|>|[-*+]\s|\d+[.)]\s)\s*/gm, "")
+        .replace(/[*_`~]/g, "")
+        .replace(/[ \t]+/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function compact(value, maximum = 280) {
+    if (!value)
+        return "";
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maximum)
+        return normalized;
+    return `${normalized.slice(0, maximum - 1).trimEnd()}…`;
+}
+function meaningfulPhrase(value, maximum = 280) {
+    const normalized = compact(value, maximum);
+    const terms = normalized.match(/[\p{L}\p{N}]+/gu) ?? [];
+    if (terms.join("").length < 3)
+        return "";
+    return normalized;
+}
+function explicitField(lines, labels) {
+    const labelPattern = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const pattern = new RegExp(`^(?:${labelPattern})\\s*[:\\-–—]\\s*(.+)$`, "i");
+    for (const line of lines) {
+        const match = line.match(pattern);
+        if (match?.[1])
+            return compact(match[1]);
+    }
+    return "";
+}
+function usefulSentences(text) {
+    // Markdown commonly hard-wraps one sentence across several lines. Treat
+    // single line breaks as whitespace so extraction never returns fragments
+    // such as “Their problem is not a”. Preserve paragraph boundaries from
+    // imported pages so headings cannot bleed into the next paragraph.
+    return text
+        .replace(/\n{2,}/g, "\u2029")
+        .replace(/\n+/g, " ")
+        .split(/(?<=[.!?])\s+|\u2029/)
+        .map((line) => meaningfulPhrase(line, 720))
+        .filter((line) => line.length >= 3 && line.length <= 720 && !INJECTION_LINE.test(line));
+}
+function firstMatching(sentences, pattern, excluded = []) {
+    const excludedKeys = new Set(excluded.flatMap((value) => [compact(value), coreProductDescription(value)])
+        .map((value) => value.toLocaleLowerCase("en-US"))
+        .filter(Boolean));
+    const preferred = sentences.find((sentence) => pattern.test(sentence) &&
+        !excludedKeys.has(compact(sentence).toLocaleLowerCase("en-US")) &&
+        !excludedKeys.has(coreProductDescription(sentence).toLocaleLowerCase("en-US")));
+    return preferred ?? sentences.find((sentence) => pattern.test(sentence)) ?? "";
+}
+/** Keep implementation details from masquerading as the product's core job. */
+function coreProductDescription(value) {
+    return compact(value
+        .replace(/,\s+(?:built|based|trained|powered)\s+(?:on|by|with)\b.+$/i, ".")
+        .replace(/\s+using\b.+$/i, "."), 420);
+}
+function extractAudience(sentences) {
+    for (const sentence of sentences) {
+        const match = sentence.match(/\b(?:built|made|designed|intended) for\s+(.+?)(?=\s+(?:who|that|to|when|so they)\b|[.;]|$)|\b(?:tool|app|product|platform|service|software|website|api|autopilot|coach|tracker)\s+for\s+(.+?)(?=\s+(?:who|that|to|when|so they|with)\b|[.;]|$)|\bhelps?\s+(.+?)(?=\s+(?:who|to|by|with|generate|create|build|find|check|manage|understand)\b|[.;]|$)|\b(?:make|build|create|design)\b.+?\bfor\s+(.+?)(?=\s+(?:who|that|to|when|so they)\b|[.;]|$)|\bwhen\s+((?:a|an)\s+.+?)(?=\s+(?:has|have|wants?|needs?)\b)/i);
+        const result = compact(match?.[1] || match?.[2] || match?.[3] || match?.[4] || match?.[5], 140);
+        if (result)
+            return result.replace(/^(?:a|an|the)\s+/i, "");
+    }
+    return "";
+}
+function workoutAutopilotSummary(text) {
+    const workout = /\b(?:workout|exercise|exerciser|reps?|sets?|pushups?|squats?|burpees?)\b/i.test(text);
+    const audio = /\b(?:audio(?:-first)?|out loud|voice|announces?|calls? every rep|podcast|music|face-down)\b/i.test(text);
+    const automation = [
+        /\bpace(?:s|d)?\b/i,
+        /\b(?:runs?|manag(?:e|es|ing))\s+(?:sets?|rests?|countdowns?|transitions?)\b/i,
+        /\b(?:logs?|records?)\b.+\b(?:automatically|result|workout|work)\b/i,
+        /\b(?:does not|doesn't|without)\s+(?:need(?:ing)? to\s+)?(?:think|look|watch|count|manage)/i,
+    ].filter((pattern) => pattern.test(text)).length;
+    if (!workout || automation < 2)
+        return {};
+    const explicitAutopilot = /\bshort[- ]workout autopilot\b/i.test(text);
+    return {
+        product: audio
+            ? "An audio-first short-workout autopilot."
+            : explicitAutopilot
+                ? "A short-workout autopilot."
+                : "A short-workout autopilot.",
+        pain: "The mental overhead of pacing, counting reps, managing sets and rests, and logging makes short workouts harder to start and finish.",
+        outcome: "Start and finish a useful short workout without watching, counting, pacing, managing rests, or logging it manually.",
+        mechanism: audio
+            ? "Calm audio paces reps, sets, rests, countdowns, and transitions while the user's podcast or music continues and the phone can stay face-down."
+            : "It carries the workout by setting the rhythm, calling each rep and transition, running rests, and recording the result.",
+    };
+}
+function splitList(input) {
+    if (!input)
+        return [];
+    return [...new Set(input.split(/[,;/]|\band\b/i).map((item) => compact(item, 80)).filter(Boolean))];
+}
+function extractJsonDescription(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+        return {};
+    try {
+        const value = JSON.parse(trimmed);
+        return {
+            product: typeof value.description === "string" ? compact(value.description) : undefined,
+            name: typeof value.name === "string" ? compact(value.name, 80) : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function mergeBrief(base, overrides) {
+    if (!overrides)
+        return base;
+    return {
+        ...base,
+        ...overrides,
+        platform: overrides.platform ? [...overrides.platform] : base.platform,
+        acquisitionChannels: overrides.acquisitionChannels
+            ? [...overrides.acquisitionChannels]
+            : base.acquisitionChannels,
+        brandTone: overrides.brandTone ? [...overrides.brandTone] : base.brandTone,
+        domainRequirements: overrides.domainRequirements
+            ? [...overrides.domainRequirements]
+            : base.domainRequirements,
+        avoid: overrides.avoid ? [...overrides.avoid] : base.avoid,
+        uncertainties: overrides.uncertainties ? [...overrides.uncertainties] : base.uncertainties,
+        evidence: overrides.evidence ? [...overrides.evidence] : base.evidence,
+    };
+}
+/**
+ * Compile an editable brief without an AI call. Embedded instructions are parsed
+ * as project data; this function never executes or delegates them.
+ */
+function compileBrief(input) {
+    const request = typeof input === "string" ? { text: input } : input;
+    if (!request || typeof request.text !== "string" || !request.text.trim()) {
+        throw new TypeError("Project context must be non-empty text.");
+    }
+    const source = request.source || "pasted context";
+    const raw = request.text;
+    const sections = sectionMap(raw);
+    const text = cleanMarkdown(raw);
+    const lines = text.split("\n").map((line) => compact(line)).filter(Boolean);
+    const sentences = usefulSentences(text);
+    const descriptiveSentences = sentences.filter((sentence) => !NAMING_GUIDANCE.test(sentence));
+    const json = extractJsonDescription(raw);
+    const workoutSummary = workoutAutopilotSummary(text);
+    const sectionProduct = sectionFirstSentence(sections.product, 420);
+    const labeledProduct = explicitField(lines, ["product", "project", "what it is", "description"]);
+    const firstTitle = meaningfulPhrase(raw.match(/^[ \t]*#[ \t]+([^\r\n]+)$/m)?.[1], 160);
+    const product = coreProductDescription(sectionProduct ||
+        labeledProduct ||
+        json.product ||
+        workoutSummary.product ||
+        firstMatching(descriptiveSentences, /\b(?:tool|(?<!\.)app|service|platform|product|website|api|cli|saas|autopilot|coach|tracker)\b/i) ||
+        firstTitle ||
+        descriptiveSentences[0] ||
+        json.name ||
+        meaningfulPhrase(text));
+    const primaryUser = sectionFirstSentence(sections.primaryUser, 520) ||
+        explicitField(lines, ["primary user", "target user", "audience", "customer", "who it is for"]) ||
+        extractAudience(descriptiveSentences);
+    const pain = sectionProse(sections.pain, 720) ||
+        explicitField(lines, ["pain", "problem", "friction", "current problem"]) ||
+        workoutSummary.pain ||
+        firstMatching(descriptiveSentences, /\b(?:mental overhead|decision(?:s| cost)|offload|stuck|struggl\w*|friction|pain|problem|stress|wast\w*|spend\w*\s+\d+.+hours?|takes?\s+\d+.+hours?|generic\s+(?:ai\s+)?(?:tools?|output)|manual|fragmented|difficult|hard to|cannot|can't)\b/i, [product]);
+    const outcome = sectionFirstSentence(sections.outcome, 720) ||
+        explicitField(lines, ["outcome", "promise", "transformation", "result", "benefit"]) ||
+        workoutSummary.outcome ||
+        firstMatching(descriptiveSentences, /\b(?:helps?|enables?|lets?|allows?|so that|so the user|without (?:watching|managing|counting|looking)|finish(?:es)? with|turns? .+ into|result|(?:one|full|complete) week of|seven .+posts|week of .+\b(?:in|without)\b|(?:customers?|users?|teams?|people)\b.+?\b(?:get|receive|finish|can)|(?:puts?|adds?|syncs?)\b.+?\b(?:calendar|dashboard|workspace|inbox|timeline|schedule))\b/i, [product]);
+    const mechanism = sectionProse(sections.mechanism, 900) ||
+        explicitField(lines, ["mechanism", "how it works", "approach", "unique mechanism"]) ||
+        workoutSummary.mechanism ||
+        firstMatching(descriptiveSentences.filter((sentence) => !/\b(?:later|roadmap|future|expand\w*|eventually)\b/i.test(sentence)), /\b(?:one (?:upload|click|guided|weekly)|drop in|approve|review|regenerate|paces?|announces?|calls? every|runs? rests?|logs? automatically|mixes? over|reads?|checks?|analy[sz]es?|generates?|produces?|compares?|imports?|uses?|uploads?|scans?|extracts?|syncs?|schedules?|organizes?|summarizes?|transcribes?|puts?|cuts?|ships?|made from|built with|powered by)\b/i, [product, outcome]);
+    const platforms = PLATFORMS.filter(([, pattern]) => pattern.test(text)).map(([label]) => label);
+    const acquisitionChannels = CHANNELS.filter(([, pattern]) => pattern.test(text)).map(([label]) => label);
+    const labeledTone = splitList(explicitField(lines, ["tone", "brand tone", "voice", "brand voice"]));
+    const detectedTone = TONES.filter((tone) => new RegExp(`\\b${tone.replace("-", "[- ]")}\\b`, "i").test(text));
+    const brandTone = [...new Set([...labeledTone, ...detectedTone])].slice(0, 8);
+    const futureCandidates = descriptiveSentences.filter((sentence) => !/\b(?:future work should|read|consult)\b.+\b(?:first|before|start)\b/i.test(sentence) &&
+        !/\b(?:does not|not own|blur|never|avoid|anti-feature|microphone listening)\b/i.test(sentence));
+    const futureExpansion = sectionProse(sections.futureExpansion, 720) ||
+        explicitField(lines, ["future expansion", "future scope", "roadmap", "long-term scope"]) ||
+        firstMatching(futureCandidates, /\b(?:expand\w*|expansion|extension|long[- ]term|roadmap|beyond|multiple movement)\b/i) ||
+        firstMatching(futureCandidates, /\b(?:future (?:scope|versions?|sessions?|product|movement|features?)|later (?:versions?|expansion)|eventually (?:support|include|expand))\b/i);
+    const explicitDomains = splitList(explicitField(lines, ["domain", "domain requirements", "tld", "preferred tld", "acceptable tlds"]));
+    const mentionedTlds = [...new Set(text.match(/\.(?:com|io|dev|app|ai|co|net|org|sh|xyz)\b/gi) ?? [])].map((item) => item.toLowerCase());
+    const domainRequirements = [...new Set([...explicitDomains, ...mentionedTlds])];
+    const naturalAvoidSentence = firstMatching(sentences, /\b(?:want to avoid|avoid|do not use|don't use)\b/i);
+    const naturalAvoid = /^avoid saying\b/i.test(naturalAvoidSentence)
+        ? undefined
+        : naturalAvoidSentence.match(/\b(?:want to avoid|avoid|do not use|don't use)\s+(.+?)(?:[.!?]|$)/i)?.[1];
+    const namingGuidanceAvoid = sentences
+        .find((sentence) => NAMING_GUIDANCE.test(sentence))
+        ?.match(/\b(?:not|rather than)\s+(.+?)(?:[.!?]|$)/i)?.[1];
+    const sectionAvoid = sectionBullets(sections.avoid);
+    const avoid = sectionAvoid.length ? sectionAvoid : splitList(explicitField(lines, ["avoid", "do not use", "names to avoid", "banned roots", "patterns to avoid"]) || naturalAvoid || namingGuidanceAvoid || "");
+    const uncertainties = [];
+    if (!product)
+        uncertainties.push(STANDARD_UNCERTAINTIES.product);
+    if (!primaryUser)
+        uncertainties.push(STANDARD_UNCERTAINTIES.primaryUser);
+    if (!pain)
+        uncertainties.push(STANDARD_UNCERTAINTIES.pain);
+    if (!outcome)
+        uncertainties.push(STANDARD_UNCERTAINTIES.outcome);
+    if (!mechanism)
+        uncertainties.push(STANDARD_UNCERTAINTIES.mechanism);
+    if (!acquisitionChannels.length)
+        uncertainties.push(STANDARD_UNCERTAINTIES.channels);
+    if (!futureExpansion)
+        uncertainties.push(STANDARD_UNCERTAINTIES.future);
+    if (!domainRequirements.length)
+        uncertainties.push(STANDARD_UNCERTAINTIES.domains);
+    if (!brandTone.length)
+        uncertainties.push(STANDARD_UNCERTAINTIES.tone);
+    if (raw.split("\n").some((line) => INJECTION_LINE.test(line))) {
+        uncertainties.push("Instruction-like text was treated as quoted project data, not executed.");
+    }
+    const fieldValues = [
+        ["product", product],
+        ["primaryUser", primaryUser],
+        ["pain", pain],
+        ["outcome", outcome],
+        ["mechanism", mechanism],
+        ["futureExpansion", futureExpansion],
+    ];
+    const evidence = fieldValues
+        .filter(([, excerpt]) => Boolean(excerpt))
+        .slice(0, 8)
+        .map(([field, excerpt]) => ({ source, excerpt, field }));
+    if (sectionAvoid.length)
+        evidence.push({ source, excerpt: sectionAvoid.join("; "), field: "avoid" });
+    return reconcileBriefUncertainties(mergeBrief({
+        product,
+        primaryUser,
+        pain,
+        outcome,
+        mechanism,
+        platform: platforms,
+        acquisitionChannels,
+        brandTone,
+        futureExpansion,
+        domainRequirements,
+        avoid,
+        uncertainties,
+        evidence,
+    }, request.overrides));
+}
+/** Keep editable-brief uncertainty messages synchronized with current values. */
+function reconcileBriefUncertainties(brief) {
+    const standard = new Set(Object.values(STANDARD_UNCERTAINTIES));
+    const preserved = (brief.uncertainties ?? []).filter((item) => !standard.has(item));
+    const uncertainties = [...preserved];
+    if (!brief.product.trim())
+        uncertainties.push(STANDARD_UNCERTAINTIES.product);
+    if (!brief.primaryUser.trim())
+        uncertainties.push(STANDARD_UNCERTAINTIES.primaryUser);
+    if (!brief.pain.trim())
+        uncertainties.push(STANDARD_UNCERTAINTIES.pain);
+    if (!brief.outcome.trim())
+        uncertainties.push(STANDARD_UNCERTAINTIES.outcome);
+    if (!brief.mechanism.trim())
+        uncertainties.push(STANDARD_UNCERTAINTIES.mechanism);
+    if (!brief.acquisitionChannels.length)
+        uncertainties.push(STANDARD_UNCERTAINTIES.channels);
+    if (!brief.futureExpansion.trim())
+        uncertainties.push(STANDARD_UNCERTAINTIES.future);
+    if (!brief.domainRequirements.length)
+        uncertainties.push(STANDARD_UNCERTAINTIES.domains);
+    if (!brief.brandTone.length)
+        uncertainties.push(STANDARD_UNCERTAINTIES.tone);
+    return { ...brief, uncertainties: [...new Set(uncertainties)] };
+}

package/dist/core/candidate-sort.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortCandidatesForDisplay = sortCandidatesForDisplay;
+function dimensionValue(candidate, key) {
+    if (key === "overall")
+        return candidate.score?.overall;
+    if (key === "editorial")
+        return candidate.aiRank;
+    return candidate.score?.dimensions.find((dimension) => dimension.key === key)?.score;
+}
+function bestDomain(candidate, tlds) {
+    return tlds
+        .map((tld) => candidate.domains?.find((domain) => domain.domain.toLowerCase().endsWith(`.${tld}`)))
+        .find((domain) => domain?.status === "likely_available");
+}
+/** Sort exactly by the named public key. AI review is never hidden inside overall score order. */
+function sortCandidatesForDisplay(candidates, key, tlds) {
+    return [...candidates].sort((left, right) => {
+        if (key === "editorial") {
+            if (left.aiRank !== undefined && right.aiRank === undefined)
+                return -1;
+            if (right.aiRank !== undefined && left.aiRank === undefined)
+                return 1;
+            if (left.aiRank !== undefined && right.aiRank !== undefined && left.aiRank !== right.aiRank) {
+                return left.aiRank - right.aiRank;
+            }
+        }
+        const leftValue = dimensionValue(left, key);
+        const rightValue = dimensionValue(right, key);
+        if (leftValue === undefined && rightValue !== undefined)
+            return 1;
+        if (rightValue === undefined && leftValue !== undefined)
+            return -1;
+        const selectedDelta = key === "editorial"
+            ? (leftValue ?? Number.MAX_SAFE_INTEGER) - (rightValue ?? Number.MAX_SAFE_INTEGER)
+            : (rightValue ?? 0) - (leftValue ?? 0);
+        if (selectedDelta)
+            return selectedDelta;
+        const leftTld = bestDomain(left, tlds)?.domain.split(".").pop();
+        const rightTld = bestDomain(right, tlds)?.domain.split(".").pop();
+        const tldDelta = (leftTld ? tlds.indexOf(leftTld) : tlds.length) - (rightTld ? tlds.indexOf(rightTld) : tlds.length);
+        if (tldDelta)
+            return tldDelta;
+        const overallDelta = (right.score?.overall ?? 0) - (left.score?.overall ?? 0);
+        return overallDelta || left.name.localeCompare(right.name);
+    });
+}

package/dist/core/candidates.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFallbackCandidates = generateFallbackCandidates;
+const brief_1 = require("./brief");
+const normalize_1 = require("./normalize");
+const brief_constraints_1 = require("./brief-constraints");
+const STOP_WORDS = new Set("a an and are as at be because been but by can could did do does for from has have helps how i in into is it its let lets may more most must no not of on or our should so than that the their them then there these they this those through to tool use user users using very was we what when where which who will with without would you your project product service platform software website application app api cli mcp build built make makes help".split(" "));
+const VEIN_PARTS = {
+    outcome: {
+        left: ["Clear", "Ready", "Open", "Bright", "Better", "Next", "Sure", "Right", "Good", "Fresh"],
+        right: ["Path", "Choice", "Signal", "Result", "Lift", "Start", "Fit", "Way", "Move", "Mark"],
+        rationale: "Frames the name around the result the user wants rather than the implementation.",
+    },
+    functional: {
+        left: ["Signal", "Context", "Pattern", "Project", "Source", "Intent", "Scope", "Brief", "Trace", "Field"],
+        right: ["Lens", "Scout", "Map", "Kit", "Forge", "Index", "Pilot", "Compass", "Lab", "Works"],
+        rationale: "Makes the product's working mechanism legible without becoming a feature list.",
+    },
+    metaphor: {
+        left: ["North", "Harbor", "Beacon", "Trail", "Bridge", "Lighthouse", "Anchor", "Cairn", "Orbit", "River"],
+        right: ["Star", "Line", "Mark", "Light", "Point", "Gate", "Stone", "Way", "Arc", "Rise"],
+        rationale: "Uses a familiar navigation or progress metaphor with room for a broader product story.",
+    },
+    trust: {
+        left: ["Proof", "True", "Known", "Sure", "Sound", "Verified", "Trust", "Solid", "Plain", "Honest"],
+        right: ["Ledger", "Signal", "Mark", "Record", "Check", "Source", "Ground", "Proof", "Base", "Guide"],
+        rationale: "Signals confidence and traceability while leaving legal or factual certainty to evidence.",
+    },
+    workflow: {
+        left: ["Name", "Launch", "Build", "Maker", "Project", "Decision", "Choice", "Shortlist", "Brand", "Venture"],
+        right: ["Desk", "Flow", "Loop", "Stack", "Board", "Lane", "Bench", "Foundry", "Dock", "Room"],
+        rationale: "Names the recurring builder workflow and can extend to adjacent decision tools.",
+    },
+    lateral: {
+        left: ["Field", "Relay", "Switch", "Thread", "Second", "Common", "Quiet", "Open", "Side", "Long"],
+        right: ["Note", "Yard", "Line", "Table", "Room", "House", "Run", "Form", "Arc", "Fold"],
+        rationale: "Moves outside category clichés to create a more ownable, memorable brand direction.",
+    },
+    coined: {
+        left: ["Noma", "Veri", "Sona", "Lumi", "Klar", "Meto", "Orbi", "Vela", "Aven", "Faro"],
+        right: ["lio", "via", "ora", "ary", "ivo", "una", "era", "ium", "aro", "ica"],
+        rationale: "Explores a compact coined form; pronunciation, language, and collision checks remain mandatory.",
+    },
+};
+const WORKOUT_VEIN_PARTS = {
+    functional: {
+        left: ["Tempo", "Pace", "Set", "Rep", "Cue", "Phase", "Rhythm", "Audio", "Motion", "Cadence"],
+        right: ["Guide", "Carry", "Steer", "Flow", "Run", "Pilot", "Path", "Voice", "Track", "Arc"],
+        rationale: "Makes the audio-guided workout mechanism legible without reducing the product to a timer.",
+    },
+    outcome: {
+        left: ["Done", "Ready", "Finish", "Steady", "Full", "Easy", "Clear", "Next", "Sure", "Calm"],
+        right: ["Flow", "Finish", "Resolve", "Carry", "Start", "Stride", "Motion", "Lift", "Run", "Way"],
+        rationale: "Centers momentum, completion, and relief from managing the workout.",
+    },
+    metaphor: {
+        left: ["Beacon", "Relay", "Compass", "Current", "Harbor", "Orbit", "Pulse", "Anchor", "Signal", "Trail"],
+        right: ["Beat", "Guide", "Arc", "Path", "Carry", "Line", "Light", "Run", "Mark", "Rise"],
+        rationale: "Uses a guidance or momentum metaphor that can extend across movement groups.",
+    },
+    lateral: {
+        left: ["Quiet", "Brio", "Drift", "Hush", "Open", "Soft", "True", "Side", "Daily", "Low"],
+        right: ["Loop", "Relay", "Arc", "Form", "Current", "Run", "Motion", "Fold", "Room", "Rise"],
+        rationale: "Creates distance from aggressive fitness and generic timer language while preserving calm motion.",
+    },
+};
+const NAMING_VEIN_PARTS = {
+    functional: {
+        left: ["Name", "Naming", "Nym", "Mark", "Decision", "Signal", "Evidence", "Proof", "Brand", "Launch"],
+        right: ["Scout", "Guide", "Lens", "Ledger", "Dossier", "Map", "Signal", "Check", "Record", "Verdict"],
+        rationale: "Makes the naming-decision workflow legible without presenting the product as a generic generator.",
+    },
+    outcome: {
+        left: ["Ready", "Clear", "Chosen", "Settled", "Done", "Sure", "Launch", "Found", "Final", "True"],
+        right: ["Name", "Choice", "Mark", "Signal", "Decision", "Launch", "Greenlight", "Result", "Pick", "Path"],
+        rationale: "Centers the move from naming uncertainty to a decision the founder can ship.",
+    },
+    metaphor: {
+        left: ["Cairn", "Beacon", "Compass", "Harbor", "Docket", "Verdict", "Record", "Trail", "Signal", "North"],
+        right: ["Mark", "Guide", "Light", "Path", "Point", "Ledger", "Line", "Proof", "Arc", "Gate"],
+        rationale: "Uses an evidence, navigation, or decision metaphor with room for a broader launch workflow.",
+    },
+    lateral: {
+        left: ["Indie", "Plain", "Quiet", "Open", "True", "Ready", "Good", "Next", "Side", "Final"],
+        right: ["Dossier", "Docket", "Signal", "Record", "Cairn", "Mark", "Choice", "Proof", "Brief", "Found"],
+        rationale: "Creates useful distance from commodity AI-generator language while retaining a defensible naming story.",
+    },
+};
+function hashString(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+}
+function rotate(values, offset) {
+    if (!values.length)
+        return [];
+    const normalized = Math.abs(offset) % values.length;
+    return [...values.slice(normalized), ...values.slice(0, normalized)];
+}
+function titleWord(value) {
+    const cleaned = (0, normalize_1.normalizeName)(value).replace(/\s+/g, "");
+    return cleaned ? `${cleaned[0].toUpperCase()}${cleaned.slice(1)}` : "";
+}
+function rootsFromBrief(brief) {
+    const fields = [brief.product, brief.outcome, brief.mechanism, brief.pain];
+    const words = fields
+        .join(" ")
+        .normalize("NFKD")
+        .replace(/\p{M}+/gu, "")
+        .toLowerCase()
+        .match(/[a-z][a-z0-9-]{2,14}/g);
+    // Keep roots as complete source words. A broad suffix stripper previously
+    // turned ordinary product language into fragments such as "naming" ->
+    // "nam" and "registered" -> "regist", which then leaked into generated
+    // names and score explanations.
+    const roots = (words ?? [])
+        .filter((word) => word.length >= 3 && word.length <= 11 && !STOP_WORDS.has(word));
+    return [...new Set(roots)].slice(0, 12);
+}
+function parseOptions(options) {
+    const input = typeof options === "number" ? { count: options } : options ?? {};
+    return {
+        count: Math.max(1, Math.min(200, Math.floor(input.count ?? 36))),
+        avoid: input.avoid ?? [],
+        existingNames: input.existingNames ?? [],
+        veins: input.veins ?? [],
+    };
+}
+/**
+ * A no-key fallback that creates a diverse, inspectable starting set. It does
+ * not imply availability or diligence; live checks happen after generation.
+ */
+function generateFallbackCandidates(input, options) {
+    const brief = typeof input === "string" ? (0, brief_1.compileBrief)(input) : input;
+    const config = parseOptions(options);
+    const seed = hashString(JSON.stringify(brief));
+    const avoidKeys = new Set([...brief.avoid, ...config.avoid, ...config.existingNames].map((value) => (0, normalize_1.comparisonKey)(value)).filter(Boolean));
+    const roots = rootsFromBrief(brief);
+    const workoutProfile = /\b(?:workout|exercise|reps?|sets?|cadence|fitness)\b/i.test([brief.product, brief.pain, brief.outcome, brief.mechanism].join(" "));
+    const namingProfile = /\b(?:product naming|naming decision|name candidates?|brand name|domain evidence|name generator)\b/i.test([brief.product, brief.pain, brief.outcome, brief.mechanism].join(" "));
+    const partsFor = (vein) => (workoutProfile ? WORKOUT_VEIN_PARTS[vein] : undefined) ??
+        (namingProfile ? NAMING_VEIN_PARTS[vein] : undefined) ??
+        VEIN_PARTS[vein];
+    const publicVeins = ["functional", "outcome", "metaphor", "lateral"];
+    const configuredVeins = config.veins.filter((vein) => publicVeins.includes(vein));
+    const veins = [...new Set(configuredVeins.length ? configuredVeins : publicVeins)];
+    const result = [];
+    const seen = new Set(avoidKeys);
+    const add = (name, vein, rationale) => {
+        const normalized = (0, normalize_1.normalizeName)(name);
+        const key = (0, normalize_1.comparisonKey)(name);
+        if (!key || key.length < 4 || key.length > 24 || seen.has(key))
+            return;
+        if ((0, brief_constraints_1.candidateAvoidViolations)(name, brief).length)
+            return;
+        if ([...avoidKeys].some((avoid) => avoid.length >= 3 && key.includes(avoid)))
+            return;
+        seen.add(key);
+        result.push({ name, normalized, vein, rationale, provider: "deterministic-fallback" });
+    };
+    // Start every direction before filling deeper combinations. This protects
+    // diversity when a caller requests a small batch.
+    for (let veinIndex = 0; veinIndex < veins.length && result.length < config.count; veinIndex += 1) {
+        const vein = veins[veinIndex];
+        const parts = partsFor(vein);
+        const left = rotate(parts.left, seed + veinIndex * 3);
+        const right = rotate(parts.right, (seed >>> 3) + veinIndex * 5);
+        add(`${left[0]}${right[0]}`, vein, parts.rationale);
+    }
+    for (let pass = 0; result.length < config.count && pass < 30; pass += 1) {
+        for (let veinIndex = 0; veinIndex < veins.length && result.length < config.count; veinIndex += 1) {
+            const vein = veins[veinIndex];
+            const parts = partsFor(vein);
+            const left = rotate(parts.left, seed + veinIndex * 3);
+            const right = rotate(parts.right, (seed >>> 3) + veinIndex * 5);
+            // The workout profile already has a curated vocabulary. Raw roots such
+            // as "audio-first" or "autopilot" create clumsy compounds and can
+            // collapse back into feature labels, so reserve root injection for the
+            // generic fallback profile.
+            const briefRoot = workoutProfile || namingProfile
+                ? ""
+                : titleWord(roots[(pass + veinIndex) % Math.max(roots.length, 1)] ?? "");
+            if (briefRoot && vein !== "coined" && pass % 2 === 0) {
+                const rootFirst = vein === "functional" || vein === "workflow";
+                add(rootFirst ? `${briefRoot}${right[pass % right.length]}` : `${left[pass % left.length]}${briefRoot}`, vein, `${parts.rationale} Draws on “${briefRoot}” from the editable project brief.`);
+            }
+            else {
+                add(`${left[pass % left.length]}${right[(pass * 3 + veinIndex) % right.length]}`, vein, parts.rationale);
+            }
+        }
+    }
+    // Preserve the brief-led ordering above for ordinary batches, then exhaust
+    // deterministic left/right combinations so sparse briefs can still fill a
+    // bounded 200-name creator sprint without inventing availability evidence.
+    for (let pair = 0; result.length < config.count && pair < 100; pair += 1) {
+        for (let veinIndex = 0; veinIndex < veins.length && result.length < config.count; veinIndex += 1) {
+            const vein = veins[veinIndex];
+            const parts = partsFor(vein);
+            const left = rotate(parts.left, seed + veinIndex * 3);
+            const right = rotate(parts.right, (seed >>> 3) + veinIndex * 5);
+            const leftIndex = Math.floor(pair / right.length) % left.length;
+            const rightIndex = (pair + veinIndex * 3) % right.length;
+            add(`${left[leftIndex]}${right[rightIndex]}`, vein, parts.rationale);
+        }
+    }
+    return result.slice(0, config.count);
+}