← All repositories

crossmate

A collaborative crossword app for iPhone and iPad

git clone https://code.inqk.net/crossmate.git


commit 4dd693c5392f7c8f48b5ef10a67fc678931338cb
parent c1c1bdca5cf80da53f9099e7294235d85eaf3578
Author: Michael Camilleri <[email protected]>
Date:   Tue, 19 May 2026 05:49:36 +0900

Rebuild puzzle generation around Fillmake, Gridmake and Pickmake

The single `Crossmake` executable that filled grids is renamed to `Fillmake`
(carrying its grid_list.json/LICENSE resources), and the SPM package now also
builds two new tools. `Gridmake` ranks grid_list.json entries by slot shape —
rewarding long slots, penalising short-slot clusters and excess slot counts —
and prints the ranking as TSV or JSON. `Pickmake` chooses a final batch from
already-filled puzzles. generate_puzzles.sh was previously git-ignored and is
now tracked under Scripts/ alongside a new select_puzzles.sh.

Fillmake's fill scoring is extended to favour cleaner, more current fill: a
per-length usage adjustment rewards common answers and punishes rare ones, a
freshness bonus keys off each answer's latest-seen year, and new concentration
and per-entry penalties push back on obscure short fill, awkward medium fill,
theme/quote fragments, novelty one-offs and phrase fragments — most applied
only past per-grid thresholds, so a handful of acceptable long or uncommon
entries still survive. The exported XD now carries Crossmate metadata:
Publisher Crossmate, CmVer 3, and Grid Index / Seed / Fill Score lines in
place of the old Source Grid date. Fillmake also gains --fill-report,
--min-fill-score and --max-answer-usages so a run can reject a weak or
answer-repeating fill on its own.

generate_puzzles.sh drives this: it builds the release binaries, selects grids
randomly by default (or from Gridmake's top-ranked set via
CROSSMAKE_GRID_SELECTION=ranked), generates EXAMPLES_PER_GRID candidates per
grid under a per-run timeout, and keeps the best-scoring fill per grid group
until the requested count is accepted.

Pickmake ranks discovered .xd candidates by their stored Fill Score (falling
back to a computed quality score), rejects any puzzle reusing an answer more
than --max-answer-usages times, then takes the requested --count while keeping
low-scoring "unusual" answers from repeating across the chosen puzzles;
--disallow-all-repeats tightens that to forbid any shared answer at all.

Wordmake records the extra evidence this relies on — clue-part, continuation
and theme clue counts plus each answer's latest-seen date — and adds curation
rejections for crosswordese, stale short/long fill, alphabet-run and
initial-plus-name artifacts, phrase fragments, and theme/continuation one-offs.

Co-Authored-By: Codex GPT 5.5 <[email protected]>

Diffstat

MCrossmake/.gitignore | 1-
MCrossmake/Package.swift | 8++++++--
ACrossmake/Scripts/generate_puzzles.sh | 362+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ACrossmake/Scripts/select_puzzles.sh | 40++++++++++++++++++++++++++++++++++++++++
RCrossmake/Sources/Crossmake/Resources/LICENSE -> Crossmake/Sources/Fillmake/Resources/LICENSE | 0
RCrossmake/Sources/Crossmake/Resources/grid_list.json -> Crossmake/Sources/Fillmake/Resources/grid_list.json | 0
RCrossmake/Sources/Crossmake/main.swift -> Crossmake/Sources/Fillmake/main.swift | 615+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
ACrossmake/Sources/Gridmake/main.swift | 279++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ACrossmake/Sources/Pickmake/main.swift | 346+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MCrossmake/Sources/Wordmake/main.swift | 228++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---

10 files changed, 1843 insertions(+), 36 deletions(-)

diff --git a/Crossmake/.gitignore b/Crossmake/.gitignore

@@ -3,4 +3,3 @@
 DerivedData/
 Data/
 Generated/
-Scripts/generate_puzzles.sh

diff --git a/Crossmake/Package.swift b/Crossmake/Package.swift

@@ -8,16 +8,20 @@ let package = Package(
         .macOS(.v13)
     ],
     products: [
-        .executable(name: "Crossmake", targets: ["Crossmake"]),
+        .executable(name: "Fillmake", targets: ["Fillmake"]),
+        .executable(name: "Gridmake", targets: ["Gridmake"]),
+        .executable(name: "Pickmake", targets: ["Pickmake"]),
         .executable(name: "Wordmake", targets: ["Wordmake"])
     ],
     targets: [
         .executableTarget(
-            name: "Crossmake",
+            name: "Fillmake",
             resources: [
                 .process("Resources")
             ]
         ),
+        .executableTarget(name: "Gridmake"),
+        .executableTarget(name: "Pickmake"),
         .executableTarget(name: "Wordmake")
     ]
 )

diff --git a/Crossmake/Scripts/generate_puzzles.sh b/Crossmake/Scripts/generate_puzzles.sh

@@ -0,0 +1,362 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CROSSMAKE_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+cd "$CROSSMAKE_DIR"
+
+DATA_DIR="Data"
+GENERATED_DIR="Generated"
+GRID_LIST="Sources/Fillmake/Resources/grid_list.json"
+WORD_LIST="${GENERATED_DIR}/word_list.json"
+COUNTS_FILE="${GENERATED_DIR}/answer_counts.json"
+QUALITY_FILE="${GENERATED_DIR}/word_quality.json"
+BAD_WORDS_FILE="${DATA_DIR}/bad_words.json"
+TIMEOUT_SECONDS="${CROSSMAKE_TIMEOUT_SECONDS:-10}"
+EXAMPLES_PER_GRID="${CROSSMAKE_EXAMPLES_PER_GRID:-4}"
+OUTPUT_PREFIX="Crossmate"
+MIN_FILL_SCORE="${CROSSMAKE_MIN_FILL_SCORE:-7500}"
+BREADTH="${CROSSMAKE_BREADTH:-80}"
+MAX_ANSWER_USAGES="${CROSSMAKE_MAX_ANSWER_USAGES:-1}"
+MAX_PARALLEL_JOBS="${CROSSMAKE_JOBS:-}"
+# Use CROSSMAKE_GRID_SELECTION=ranked to sample from Gridmake's top-ranked grids.
+GRID_SELECTION="${CROSSMAKE_GRID_SELECTION:-random}"
+GRID_RANK_LIMIT="${CROSSMAKE_GRID_RANK_LIMIT:-250}"
+FIXED_GRID_INDEX="${CROSSMAKE_GRID_INDEX:-}"
+FIXED_SEED="${CROSSMAKE_SEED:-}"
+TARGET_PUZZLES="${1:-10}"
+FILLMAKE_EXECUTABLE=".build/release/Fillmake"
+GRIDMAKE_EXECUTABLE=".build/release/Gridmake"
+
+if [[ ! -f "$WORD_LIST" ]]; then
+  echo "Word list not found: $WORD_LIST" >&2
+  exit 1
+fi
+
+if [[ ! -f "$GRID_LIST" ]]; then
+  echo "Grid list not found: $GRID_LIST" >&2
+  exit 1
+fi
+
+if [[ ! -f "$COUNTS_FILE" ]]; then
+  echo "Answer counts not found: $COUNTS_FILE" >&2
+  exit 1
+fi
+
+if [[ ! -f "$QUALITY_FILE" ]]; then
+  echo "Word quality metadata not found: $QUALITY_FILE" >&2
+  exit 1
+fi
+
+if [[ ! -f "$BAD_WORDS_FILE" ]]; then
+  echo "Bad-word list not found: $BAD_WORDS_FILE" >&2
+  exit 1
+fi
+
+if ! command -v jq >/dev/null 2>&1; then
+  echo "jq is required to read $GRID_LIST" >&2
+  exit 1
+fi
+
+if [[ -z "$MAX_PARALLEL_JOBS" ]]; then
+  MAX_PARALLEL_JOBS="$(sysctl -n hw.ncpu 2>/dev/null || getconf _NPROCESSORS_ONLN 2>/dev/null || echo 4)"
+  if ((MAX_PARALLEL_JOBS > 4)); then
+    MAX_PARALLEL_JOBS=4
+  fi
+fi
+
+if ! [[ "$MAX_PARALLEL_JOBS" =~ ^[0-9]+$ ]] || ((10#$MAX_PARALLEL_JOBS < 1)); then
+  echo "CROSSMAKE_JOBS must be a positive integer" >&2
+  exit 1
+fi
+
+if ! [[ "$TIMEOUT_SECONDS" =~ ^[0-9]+([.][0-9]+)?$ ]]; then
+  echo "CROSSMAKE_TIMEOUT_SECONDS must be a positive number" >&2
+  exit 1
+fi
+
+if ! [[ "$EXAMPLES_PER_GRID" =~ ^[0-9]+$ ]] || ((10#$EXAMPLES_PER_GRID < 1)); then
+  echo "CROSSMAKE_EXAMPLES_PER_GRID must be a positive integer" >&2
+  exit 1
+fi
+
+if ! [[ "$MIN_FILL_SCORE" =~ ^-?[0-9]+$ ]]; then
+  echo "CROSSMAKE_MIN_FILL_SCORE must be an integer" >&2
+  exit 1
+fi
+
+if ! [[ "$BREADTH" =~ ^[0-9]+$ ]] || ((10#$BREADTH < 1)); then
+  echo "CROSSMAKE_BREADTH must be a positive integer" >&2
+  exit 1
+fi
+
+if ! [[ "$MAX_ANSWER_USAGES" =~ ^[0-9]+$ ]] || ((10#$MAX_ANSWER_USAGES < 1)); then
+  echo "CROSSMAKE_MAX_ANSWER_USAGES must be a positive integer" >&2
+  exit 1
+fi
+
+if [[ "$GRID_SELECTION" != "ranked" && "$GRID_SELECTION" != "random" ]]; then
+  echo "CROSSMAKE_GRID_SELECTION must be ranked or random" >&2
+  exit 1
+fi
+
+if [[ -n "$FIXED_GRID_INDEX" ]] && ! [[ "$FIXED_GRID_INDEX" =~ ^[0-9]+$ ]]; then
+  echo "CROSSMAKE_GRID_INDEX must be a non-negative integer" >&2
+  exit 1
+fi
+
+if [[ -n "$FIXED_SEED" ]] && ! [[ "$FIXED_SEED" =~ ^[0-9]+$ ]]; then
+  echo "CROSSMAKE_SEED must be a non-negative integer" >&2
+  exit 1
+fi
+
+if ! [[ "$GRID_RANK_LIMIT" =~ ^[0-9]+$ ]] || ((10#$GRID_RANK_LIMIT < 1)); then
+  echo "CROSSMAKE_GRID_RANK_LIMIT must be a positive integer" >&2
+  exit 1
+fi
+
+if ! [[ "$TARGET_PUZZLES" =~ ^[0-9]+$ ]]; then
+  echo "Usage: $0 [positive-puzzle-count]" >&2
+  exit 1
+fi
+
+target_puzzle_count=$((10#$TARGET_PUZZLES))
+if ((target_puzzle_count < 1)); then
+  echo "Usage: $0 [positive-puzzle-count]" >&2
+  exit 1
+fi
+
+next_output_number() {
+  local highest=0
+  local path filename number number_value
+
+  for path in "${GENERATED_DIR}/${OUTPUT_PREFIX}-"*.xd; do
+    [[ -e "$path" ]] || continue
+    filename="${path##*/}"
+    [[ "$filename" =~ ^${OUTPUT_PREFIX}-([0-9]+)\.xd$ ]] || continue
+    number="${BASH_REMATCH[1]}"
+    number_value=$((10#$number))
+    if ((number_value > highest)); then
+      highest="$number_value"
+    fi
+  done
+
+  echo "$((highest + 1))"
+}
+
+output_number="$(next_output_number)"
+mkdir -p "$GENERATED_DIR"
+tmp_dir="$(mktemp -d)"
+trap 'rm -rf "$tmp_dir"' EXIT
+
+echo "Building Fillmake in release mode"
+swift build -c release
+
+if [[ ! -x "$FILLMAKE_EXECUTABLE" ]]; then
+  echo "Fillmake executable not found after build: $FILLMAKE_EXECUTABLE" >&2
+  exit 1
+fi
+
+if [[ ! -x "$GRIDMAKE_EXECUTABLE" ]]; then
+  echo "Gridmake executable not found after build: $GRIDMAKE_EXECUTABLE" >&2
+  exit 1
+fi
+
+available_grid_count="$(jq 'length' "$GRID_LIST")"
+grid_indices="$tmp_dir/grid-indices.txt"
+
+if [[ -n "$FIXED_GRID_INDEX" ]]; then
+  if ((10#$FIXED_GRID_INDEX >= available_grid_count)); then
+    echo "CROSSMAKE_GRID_INDEX ${FIXED_GRID_INDEX} is out of range; found ${available_grid_count} grids" >&2
+    exit 1
+  fi
+  echo "$FIXED_GRID_INDEX" >"$grid_indices"
+elif [[ "$GRID_SELECTION" == "ranked" ]]; then
+  "$GRIDMAKE_EXECUTABLE" --grids "$GRID_LIST" --limit "$GRID_RANK_LIMIT" \
+    | awk 'NR > 1 { print $2 }' >"$grid_indices"
+else
+  for ((grid_index = 0; grid_index < available_grid_count; grid_index++)); do
+    echo "$grid_index"
+  done >"$grid_indices"
+fi
+
+selection_grid_count="$(wc -l <"$grid_indices" | tr -d '[:space:]')"
+if ((10#$selection_grid_count < 1)); then
+  echo "No grids available for selection" >&2
+  exit 1
+fi
+
+selected_indices=()
+while IFS= read -r selected_index; do
+  selected_indices+=("$selected_index")
+done <"$grid_indices"
+
+random_grid_index() {
+  echo "${selected_indices[$((RANDOM % selection_grid_count))]}"
+}
+
+if [[ -n "$FIXED_GRID_INDEX" ]]; then
+  echo "Generating ${target_puzzle_count} puzzle(s) from fixed grid ${FIXED_GRID_INDEX} with ${EXAMPLES_PER_GRID} fill attempt(s) per puzzle, ${MAX_PARALLEL_JOBS} parallel job(s), timeout ${TIMEOUT_SECONDS}s per run, breadth ${BREADTH}, min score ${MIN_FILL_SCORE}, max answer usage ${MAX_ANSWER_USAGES}"
+elif [[ "$GRID_SELECTION" == "ranked" ]]; then
+  echo "Generating ${target_puzzle_count} puzzle(s) from the top ${selection_grid_count} ranked grid(s) with ${EXAMPLES_PER_GRID} fill attempt(s) per puzzle, ${MAX_PARALLEL_JOBS} parallel job(s), timeout ${TIMEOUT_SECONDS}s per run, breadth ${BREADTH}, min score ${MIN_FILL_SCORE}, max answer usage ${MAX_ANSWER_USAGES}"
+else
+  echo "Generating ${target_puzzle_count} puzzle(s) from ${selection_grid_count} random grid(s) with ${EXAMPLES_PER_GRID} fill attempt(s) per puzzle, ${MAX_PARALLEL_JOBS} parallel job(s), timeout ${TIMEOUT_SECONDS}s per run, breadth ${BREADTH}, min score ${MIN_FILL_SCORE}, max answer usage ${MAX_ANSWER_USAGES}"
+fi
+
+running_job_count() {
+  jobs -rp | wc -l | tr -d '[:space:]'
+}
+
+wait_for_job_slot() {
+  while ((10#$(running_job_count) >= 10#$MAX_PARALLEL_JOBS)); do
+    sleep 1
+  done
+}
+
+candidate_index=0
+
+start_candidate() {
+  local group_id="$1"
+  local grid_index="$2"
+  local example="$3"
+  local candidate_id="$4"
+  local seed="$5"
+  local output_path="${tmp_dir}/candidate-${candidate_id}.xd"
+  local log_path="${tmp_dir}/candidate-${candidate_id}.log"
+  local ok_path="${tmp_dir}/candidate-${candidate_id}.ok"
+  local status_path="${tmp_dir}/candidate-${candidate_id}.status"
+  local group_path="${tmp_dir}/candidate-${candidate_id}.group"
+
+  candidate_outputs+=("$output_path")
+  echo "$group_id" >"$group_path"
+  echo "Generating candidate ${candidate_id} from grid index ${grid_index} (${example}/${EXAMPLES_PER_GRID}) with seed ${seed}"
+
+  (
+    set +e
+    "$FILLMAKE_EXECUTABLE" \
+      --words "$WORD_LIST" \
+      --counts "$COUNTS_FILE" \
+      --quality "$QUALITY_FILE" \
+      --bad-words "$BAD_WORDS_FILE" \
+      --grid-index "$grid_index" \
+      --seed "$seed" \
+      --timeout "$TIMEOUT_SECONDS" \
+      --breadth "$BREADTH" \
+      --optimize-fill \
+      --min-fill-score "$MIN_FILL_SCORE" \
+      --max-answer-usages "$MAX_ANSWER_USAGES" \
+      --output "$output_path" >"$log_path" 2>&1
+    status="$?"
+    echo "$status" >"$status_path"
+    if [[ "$status" == "0" ]]; then
+      touch "$ok_path"
+    fi
+  ) &
+}
+
+accepted_count=0
+rejected_count=0
+discarded_count=0
+attempted_group_count=0
+
+fill_score_for_log() {
+  local log_path="$1"
+  local score
+
+  score="$(
+    awk '
+      /kept best fill score/ {
+        value = $(NF)
+        gsub(/\./, "", value)
+        print value
+      }
+      /Selected fill score:/ {
+        print $NF
+      }
+    ' "$log_path" | tail -1
+  )"
+
+  if [[ -n "$score" ]]; then
+    echo "$score"
+  else
+    echo "-999999999"
+  fi
+}
+
+run_grid_group() {
+  local group_id="$1"
+  local grid_index="$2"
+  best_candidate_id=""
+  best_output_path=""
+  best_score="-999999999"
+  candidate_outputs=()
+
+  echo "Starting grid group ${group_id} from grid index ${grid_index}"
+
+  for ((example = 1; example <= EXAMPLES_PER_GRID; example++)); do
+    wait_for_job_slot
+    candidate_index=$((candidate_index + 1))
+    if [[ -n "$FIXED_SEED" ]]; then
+      seed="$FIXED_SEED"
+    else
+      seed="$(($(date +%s) * 1000000 + candidate_index * 1000 + RANDOM))"
+    fi
+    start_candidate "$group_id" "$grid_index" "$example" "$candidate_index" "$seed"
+  done
+
+  wait
+
+  for output_path in "${candidate_outputs[@]}"; do
+    candidate_id="${output_path##*/candidate-}"
+    candidate_id="${candidate_id%.xd}"
+    group_path="${tmp_dir}/candidate-${candidate_id}.group"
+    ok_path="${tmp_dir}/candidate-${candidate_id}.ok"
+    log_path="${tmp_dir}/candidate-${candidate_id}.log"
+
+    [[ -f "$group_path" ]] || continue
+    [[ "$(cat "$group_path")" == "$group_id" ]] || continue
+    [[ -f "$ok_path" ]] || continue
+
+    score="$(fill_score_for_log "$log_path")"
+    if ((score > best_score)); then
+      best_score="$score"
+      best_candidate_id="$candidate_id"
+      best_output_path="$output_path"
+    fi
+  done
+
+  if [[ -n "$best_candidate_id" ]]; then
+    printf -v final_output_path "%s/%s-%04d.xd" "$GENERATED_DIR" "$OUTPUT_PREFIX" "$output_number"
+    mv "$best_output_path" "$final_output_path"
+    echo "Wrote ${final_output_path} from candidate ${best_candidate_id}"
+    grep -E "Searched .* seconds|Selected fill score:" "${tmp_dir}/candidate-${best_candidate_id}.log" || true
+    output_number=$((output_number + 1))
+    accepted_count=$((accepted_count + 1))
+  else
+    echo "No accepted fill for grid group ${group_id}." >&2
+  fi
+
+  for output_path in "${candidate_outputs[@]}"; do
+    candidate_id="${output_path##*/candidate-}"
+    candidate_id="${candidate_id%.xd}"
+    log_path="${tmp_dir}/candidate-${candidate_id}.log"
+    ok_path="${tmp_dir}/candidate-${candidate_id}.ok"
+
+    if [[ -f "$ok_path" ]]; then
+      if [[ -e "$output_path" ]]; then
+        discarded_count=$((discarded_count + 1))
+      fi
+    else
+      rejected_count=$((rejected_count + 1))
+      echo "Rejected candidate ${candidate_id}:" >&2
+      tail -3 "$log_path" >&2 || true
+    fi
+  done
+}
+
+while ((accepted_count < target_puzzle_count)); do
+  attempted_group_count=$((attempted_group_count + 1))
+  run_grid_group "$attempted_group_count" "$(random_grid_index)"
+done
+
+echo "Accepted ${accepted_count} puzzle(s) after ${attempted_group_count} grid group(s); discarded ${discarded_count} lower-scoring accepted fill(s); rejected ${rejected_count}."

diff --git a/Crossmake/Scripts/select_puzzles.sh b/Crossmake/Scripts/select_puzzles.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+COUNT="${1:-10}"
+CANDIDATE_DIR="${2:-Generated}"
+PICKMAKE_EXECUTABLE=".build/release/Pickmake"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CROSSMAKE_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+CALLER_DIR="$(pwd)"
+
+if ! [[ "$COUNT" =~ ^[0-9]+$ ]] || ((10#$COUNT < 1)); then
+  echo "Usage: $0 [positive-puzzle-count] [candidate-dir-or-xd-file ...]" >&2
+  exit 1
+fi
+
+shift || true
+inputs=()
+if (($# == 0)); then
+  inputs+=("${CROSSMAKE_DIR}/${CANDIDATE_DIR}")
+else
+  for input in "$@"; do
+    if [[ "$input" = /* ]]; then
+      inputs+=("$input")
+    else
+      inputs+=("${CALLER_DIR}/${input}")
+    fi
+  done
+fi
+
+cd "$CROSSMAKE_DIR"
+
+echo "Building Pickmake in release mode" >&2
+swift build -c release --product Pickmake
+
+if [[ ! -x "$PICKMAKE_EXECUTABLE" ]]; then
+  echo "Pickmake executable not found after build: $PICKMAKE_EXECUTABLE" >&2
+  exit 1
+fi
+
+"$PICKMAKE_EXECUTABLE" --count "$COUNT" --verbose "${inputs[@]}"

diff --git a/Crossmake/Sources/Crossmake/Resources/LICENSE b/Crossmake/Sources/Fillmake/Resources/LICENSE

diff --git a/Crossmake/Sources/Crossmake/Resources/grid_list.json b/Crossmake/Sources/Fillmake/Resources/grid_list.json

diff --git a/Crossmake/Sources/Crossmake/main.swift b/Crossmake/Sources/Fillmake/main.swift

@@ -15,15 +15,18 @@ struct Options {
     var countsPath = "Generated/answer_counts.json"
     var qualityPath = "Generated/word_quality.json"
     var badWordsPath = "Data/bad_words.json"
-    var outputPath = "Generated/crossmake.xd"
+    var outputPath = "Generated/fillmake.xd"
     var gridIndex = 1
     var gridDate: String?
     var seed: UInt64 = UInt64(Date().timeIntervalSince1970)
     var timeout: TimeInterval = 30
     var breadth = 15
-    var title = "Crossmake Puzzle"
-    var author = "Crossmake"
+    var title = "Fillmake Puzzle"
+    var author = "Fillmake"
     var optimizeFill = false
+    var fillReport = false
+    var minFillScore: Int?
+    var maxAnswerUsages = 2
 }
 
 struct GridEntry: Decodable {
@@ -48,11 +51,22 @@ struct Word {
     let score: Int
 }
 
+struct WordBucket {
+    let words: [Word]
+    let indexesByPositionAndLetter: [[UInt8: [Int]]]
+}
+
 struct WordQuality: Decodable {
     let count: Int?
     let badClueCount: Int?
     let obscureNameClueCount: Int?
     let fillBlankCount: Int?
+    let foreignLanguageClueCount: Int?
+    let cluePartCount: Int?
+    let continuationClueCount: Int?
+    let themeClueCount: Int?
+    let latestSeen: String?
+    let sampleClues: [String]?
     let rejectionReason: String?
 
     enum CodingKeys: String, CodingKey {
@@ -60,13 +74,38 @@ struct WordQuality: Decodable {
         case badClueCount = "bad_clue_count"
         case obscureNameClueCount = "obscure_name_clue_count"
         case fillBlankCount = "fill_blank_count"
+        case foreignLanguageClueCount = "foreign_language_clue_count"
+        case cluePartCount = "clue_part_count"
+        case continuationClueCount = "continuation_clue_count"
+        case themeClueCount = "theme_clue_count"
+        case latestSeen = "latest_seen"
+        case sampleClues = "sample_clues"
         case rejectionReason = "rejection_reason"
     }
 }
 
+struct WordProfile {
+    let text: String
+    let length: Int
+    let score: Int
+    let count: Int
+    let badClueCount: Int
+    let obscureNameClueCount: Int
+    let fillBlankCount: Int
+    let foreignLanguageClueCount: Int
+    let cluePartCount: Int
+    let continuationClueCount: Int
+    let themeClueCount: Int
+    let latestSeen: String?
+    let sampleClues: [String]
+    let freshnessScore: Int
+    let rejectionReason: String?
+}
+
 struct Dictionary {
-    let wordsByLength: [Int: [Word]]
+    let bucketsByLength: [Int: WordBucket]
     let scoresByText: [String: Int]
+    let profilesByText: [String: WordProfile]
 }
 
 struct PuzzleState {
@@ -153,6 +192,20 @@ func parseOptions(_ arguments: [String]) throws -> Options {
             options.author = try requireValue(arg)
         case "--optimize-fill":
             options.optimizeFill = true
+        case "--fill-report":
+            options.fillReport = true
+        case "--min-fill-score":
+            let value = try requireValue(arg)
+            guard let parsed = Int(value) else {
+                throw GeneratorError(description: "--min-fill-score must be an integer")
+            }
+            options.minFillScore = parsed
+        case "--max-answer-usages":
+            let value = try requireValue(arg)
+            guard let parsed = Int(value), parsed > 0 else {
+                throw GeneratorError(description: "--max-answer-usages must be a positive integer")
+            }
+            options.maxAnswerUsages = parsed
         case "--help", "-h":
             printUsage()
             exit(0)
@@ -167,10 +220,10 @@ func parseOptions(_ arguments: [String]) throws -> Options {
 
 func printUsage() {
     print("""
-    Usage: Crossmake [options]
+    Usage: Fillmake [options]
 
     Options:
-      -o, --output PATH       Output XD file path. Default: Generated/crossmake.xd
+      -o, --output PATH       Output XD file path. Default: Generated/fillmake.xd
       --words PATH            Word list JSON path. Default: Generated/word_list.json
       --grids PATH            Grid list JSON path. Default: bundled grid_list.json
       --counts PATH           Optional answer frequency JSON path. Default: Generated/answer_counts.json
@@ -184,6 +237,9 @@ func printUsage() {
       --title TEXT            XD title metadata.
       --author TEXT           XD author metadata.
       --optimize-fill         Keep searching until timeout and return the best-scored fill found.
+      --fill-report           Print the weakest entries in the selected fill.
+      --min-fill-score N      Reject the selected fill if its final score is below N.
+      --max-answer-usages N   Reject fills using one answer more than N times. Default: 2
       -h, --help              Show this help.
     """)
 }
@@ -234,6 +290,179 @@ func hasRunOfThree(_ bytes: [UInt8]) -> Bool {
     return false
 }
 
+func year(fromISODate value: String?) -> Int? {
+    guard let value, value.count >= 4 else {
+        return nil
+    }
+    return Int(value.prefix(4))
+}
+
+func freshnessScore(latestSeen: String?) -> Int {
+    guard let year = year(fromISODate: latestSeen) else {
+        return 0
+    }
+    if year >= 2015 {
+        return 55
+    }
+    if year >= 2010 {
+        return 35
+    }
+    if year >= 2000 {
+        return 15
+    }
+    if year < 1985 {
+        return -25
+    }
+    return 0
+}
+
+func usageAdjustment(length: Int, frequency: Int) -> Int {
+    guard frequency > 0 else {
+        return 0
+    }
+
+    switch length {
+    case ...3:
+        if frequency >= 100 { return 70 }
+        if frequency >= 50 { return 35 }
+        return -70
+    case 4:
+        if frequency >= 100 { return 60 }
+        if frequency >= 50 { return 30 }
+        if frequency < 20 { return -55 }
+    case 5:
+        if frequency >= 50 { return 45 }
+        if frequency >= 20 { return 20 }
+        if frequency < 10 { return -35 }
+    case 6...7:
+        if frequency >= 30 { return 25 }
+        if frequency < 5 { return -30 }
+    default:
+        if frequency >= 10 { return 15 }
+        if frequency == 1 { return -15 }
+    }
+
+    return 0
+}
+
+func lowUsageThreshold(length: Int) -> Int? {
+    switch length {
+    case ...3:
+        return 50
+    case 4:
+        return 20
+    case 5:
+        return 10
+    case 6...7:
+        return 5
+    default:
+        return nil
+    }
+}
+
+func isLowUsageFill(_ profile: WordProfile) -> Bool {
+    guard let threshold = lowUsageThreshold(length: profile.length) else {
+        return false
+    }
+    return profile.count < threshold
+}
+
+func isObscureShortFill(_ profile: WordProfile) -> Bool {
+    guard profile.length <= 4 else {
+        return false
+    }
+
+    let badRatio = ratio(profile.badClueCount, profile.count)
+    let obscureRatio = ratio(profile.obscureNameClueCount, profile.count)
+    let blankRatio = ratio(profile.fillBlankCount, profile.count)
+    let foreignRatio = ratio(profile.foreignLanguageClueCount, profile.count)
+
+    if isLowUsageFill(profile) {
+        return true
+    }
+    if profile.length <= 3 && profile.count < 80 {
+        return true
+    }
+    if profile.score < 130 {
+        return true
+    }
+
+    return badRatio >= 0.18
+        || obscureRatio >= 0.18
+        || blankRatio >= 0.25
+        || foreignRatio >= 0.18
+}
+
+func sampleCluesContain(_ profile: WordProfile, patterns: [String]) -> Bool {
+    profile.sampleClues.contains { clue in
+        let normalized = clue.lowercased()
+        return patterns.contains { normalized.contains($0) }
+    }
+}
+
+func isThemeOrQuoteFragment(_ profile: WordProfile) -> Bool {
+    if profile.continuationClueCount > 0 || profile.themeClueCount > 0 || profile.cluePartCount > 0 {
+        return true
+    }
+
+    let text = profile.text
+    if text.hasPrefix("IFA") || text.hasPrefix("IFAT") || text.hasPrefix("ITSREALLY") {
+        return true
+    }
+    if profile.length >= 8 && sampleCluesContain(profile, patterns: ["-across", "-down"]) {
+        return true
+    }
+
+    return sampleCluesContain(profile, patterns: [
+        "start of",
+        "end of",
+        "middle of",
+        "part of",
+        "continuation of",
+        "quote",
+        "quip",
+        "reason the",
+        "17-across",
+        "58-across",
+        "39-down"
+    ])
+}
+
+func isAwkwardMediumFill(_ profile: WordProfile) -> Bool {
+    guard (5...7).contains(profile.length) else {
+        return false
+    }
+
+    if profile.count <= 8 {
+        return true
+    }
+    if ratio(profile.fillBlankCount, profile.count) >= 0.35 {
+        return true
+    }
+    return false
+}
+
+func isNoveltyOneOff(_ profile: WordProfile) -> Bool {
+    guard profile.length >= 8, profile.count == 1 else {
+        return false
+    }
+
+    if isThemeOrQuoteFragment(profile) {
+        return true
+    }
+
+    return sampleCluesContain(profile, patterns: [
+        "guinness",
+        "world record",
+        "record at",
+        "#",
+        "dumbest",
+        "largest",
+        "longest",
+        "smallest"
+    ])
+}
+
 func qualityScore(text: String, bytes: [UInt8], count: Int?, quality: WordQuality?) -> Int {
     let length = bytes.count
     let frequency = count ?? 0
@@ -241,6 +470,7 @@ func qualityScore(text: String, bytes: [UInt8], count: Int?, quality: WordQualit
 
     if frequency > 0 {
         score += min(80, frequency * 4)
+        score += usageAdjustment(length: length, frequency: frequency)
     } else {
         score -= length >= 8 ? 30 : 80
     }
@@ -292,7 +522,7 @@ func qualityScore(text: String, bytes: [UInt8], count: Int?, quality: WordQualit
     }
 
     let letterScore = bytes.reduce(0) { $0 + (letterWeights[$1] ?? 0) }
-    return score + letterScore
+    return score + letterScore + freshnessScore(latestSeen: quality?.latestSeen)
 }
 
 func loadDictionary(path: String, countsPath: String, qualityPath: String, badWordsPath: String) throws -> Dictionary {
@@ -303,6 +533,7 @@ func loadDictionary(path: String, countsPath: String, qualityPath: String, badWo
     var seen = Set<String>()
     var grouped: [Int: [Word]] = [:]
     var scoresByText: [String: Int] = [:]
+    var profilesByText: [String: WordProfile] = [:]
 
     for rawWord in rawWords {
         let upper = rawWord.uppercased()
@@ -317,11 +548,31 @@ func loadDictionary(path: String, countsPath: String, qualityPath: String, badWo
             continue
         }
         let key = upper.lowercased()
-        let score = qualityScore(text: upper, bytes: bytes, count: counts[key], quality: quality[key])
+        let wordQuality = quality[key]
+        let frequency = counts[key] ?? wordQuality?.count ?? 0
+        let score = qualityScore(text: upper, bytes: bytes, count: counts[key], quality: wordQuality)
         grouped[bytes.count, default: []].append(Word(text: upper, bytes: bytes, score: score))
         scoresByText[upper] = score
+        profilesByText[upper] = WordProfile(
+            text: upper,
+            length: bytes.count,
+            score: score,
+            count: frequency,
+            badClueCount: wordQuality?.badClueCount ?? 0,
+            obscureNameClueCount: wordQuality?.obscureNameClueCount ?? 0,
+            fillBlankCount: wordQuality?.fillBlankCount ?? 0,
+            foreignLanguageClueCount: wordQuality?.foreignLanguageClueCount ?? 0,
+            cluePartCount: wordQuality?.cluePartCount ?? 0,
+            continuationClueCount: wordQuality?.continuationClueCount ?? 0,
+            themeClueCount: wordQuality?.themeClueCount ?? 0,
+            latestSeen: wordQuality?.latestSeen,
+            sampleClues: wordQuality?.sampleClues ?? [],
+            freshnessScore: freshnessScore(latestSeen: wordQuality?.latestSeen),
+            rejectionReason: wordQuality?.rejectionReason
+        )
     }
 
+    var bucketsByLength: [Int: WordBucket] = [:]
     for length in grouped.keys {
         grouped[length]?.sort {
             if $0.score != $1.score {
@@ -329,12 +580,22 @@ func loadDictionary(path: String, countsPath: String, qualityPath: String, badWo
             }
             return $0.text < $1.text
         }
+        guard let words = grouped[length] else {
+            continue
+        }
+        var indexesByPositionAndLetter = Array(repeating: [UInt8: [Int]](), count: length)
+        for (index, word) in words.enumerated() {
+            for (position, letter) in word.bytes.enumerated() {
+                indexesByPositionAndLetter[position][letter, default: []].append(index)
+            }
+        }
+        bucketsByLength[length] = WordBucket(words: words, indexesByPositionAndLetter: indexesByPositionAndLetter)
     }
 
-    return Dictionary(wordsByLength: grouped, scoresByText: scoresByText)
+    return Dictionary(bucketsByLength: bucketsByLength, scoresByText: scoresByText, profilesByText: profilesByText)
 }
 
-func loadGrid(options: Options) throws -> ([Bool], String) {
+func loadGrid(options: Options) throws -> ([Bool], Int) {
     let grids: [GridEntry]
     if let gridsPath = options.gridsPath {
         grids = try loadJSON([GridEntry].self, from: gridsPath)
@@ -343,24 +604,27 @@ func loadGrid(options: Options) throws -> ([Bool], String) {
     }
 
     let entry: GridEntry
+    let gridIndex: Int
     if let date = options.gridDate {
         let normalizedDate = normalizedGridDate(date)
-        guard let match = grids.first(where: { $0.date == normalizedDate }) else {
+        guard let matchIndex = grids.firstIndex(where: { $0.date == normalizedDate }) else {
             throw GeneratorError(description: "No grid found for date \(date)")
         }
-        entry = match
+        entry = grids[matchIndex]
+        gridIndex = matchIndex
     } else {
         guard options.gridIndex < grids.count else {
             throw GeneratorError(description: "--grid-index \(options.gridIndex) is out of range; found \(grids.count) grids")
         }
         entry = grids[options.gridIndex]
+        gridIndex = options.gridIndex
     }
 
     guard entry.grid.count == gridSize * gridSize else {
         throw GeneratorError(description: "Grid \(entry.date) has \(entry.grid.count) cells, expected \(gridSize * gridSize)")
     }
 
-    return (entry.grid.map { $0 == "." }, entry.date)
+    return (entry.grid.map { $0 == "." }, gridIndex)
 }
 
 func buildSlots(black: [Bool]) -> [Slot] {
@@ -432,8 +696,60 @@ func matches(_ word: Word, slot: Slot, state: PuzzleState) -> Bool {
     return true
 }
 
+func intersectSorted(_ lhs: [Int], _ rhs: [Int]) -> [Int] {
+    var result: [Int] = []
+    result.reserveCapacity(min(lhs.count, rhs.count))
+    var leftIndex = 0
+    var rightIndex = 0
+
+    while leftIndex < lhs.count && rightIndex < rhs.count {
+        let left = lhs[leftIndex]
+        let right = rhs[rightIndex]
+        if left == right {
+            result.append(left)
+            leftIndex += 1
+            rightIndex += 1
+        } else if left < right {
+            leftIndex += 1
+        } else {
+            rightIndex += 1
+        }
+    }
+
+    return result
+}
+
 func candidates(for slot: Slot, state: PuzzleState, dictionary: Dictionary) -> [Word] {
-    (dictionary.wordsByLength[slot.cells.count] ?? []).filter { matches($0, slot: slot, state: state) }
+    guard let bucket = dictionary.bucketsByLength[slot.cells.count] else {
+        return []
+    }
+
+    var indexedMatches: [Int]?
+    for (offset, cell) in slot.cells.enumerated() {
+        guard let existing = state.board[cell] else {
+            continue
+        }
+        guard let letterMatches = bucket.indexesByPositionAndLetter[offset][existing] else {
+            return []
+        }
+        if let current = indexedMatches {
+            indexedMatches = intersectSorted(current, letterMatches)
+            if indexedMatches?.isEmpty == true {
+                return []
+            }
+        } else {
+            indexedMatches = letterMatches
+        }
+    }
+
+    let words: [Word]
+    if let indexedMatches {
+        words = indexedMatches.map { bucket.words[$0] }
+    } else {
+        words = bucket.words
+    }
+
+    return words.filter { matches($0, slot: slot, state: state) }
 }
 
 func propagate(_ input: PuzzleState, slots: [Slot], dictionary: Dictionary) -> PuzzleState? {
@@ -530,6 +846,7 @@ func solve(
     timeout: TimeInterval,
     breadth: Int,
     optimizeFill: Bool,
+    maxAnswerUsages: Int,
     rng: inout RandomNumberGenerator64
 ) -> PuzzleState? {
     var initial = PuzzleState(
@@ -540,7 +857,8 @@ func solve(
         initial.board[cell] = nil
     }
 
-    let deadline = Date().addingTimeInterval(timeout)
+    let startedAt = Date()
+    let deadline = startedAt.addingTimeInterval(timeout)
     var attempts = 0
     var bestSolved: PuzzleState?
     var bestSolvedScore = Int.min
@@ -555,6 +873,9 @@ func solve(
             return nil
         }
         if isSolved(propagated, black: black) {
+            guard repeatedAnswers(in: propagated, slots: slots, maxUsage: maxAnswerUsages).isEmpty else {
+                return nil
+            }
             if optimizeFill {
                 let score = fillScore(state: propagated, slots: slots, dictionary: dictionary)
                 if score > bestSolvedScore {
@@ -586,11 +907,13 @@ func solve(
         return result
     }
     if let bestSolved {
-        fputs("Searched \(attempts) nodes and kept best fill score \(bestSolvedScore).\n", stderr)
+        let elapsed = Date().timeIntervalSince(startedAt)
+        fputs("Searched \(attempts) nodes in \(String(format: "%.2f", elapsed)) seconds and kept best fill score \(bestSolvedScore).\n", stderr)
         return bestSolved
     }
     if result == nil {
-        fputs("Stopped after \(attempts) search nodes.\n", stderr)
+        let elapsed = Date().timeIntervalSince(startedAt)
+        fputs("Stopped after \(attempts) search nodes in \(String(format: "%.2f", elapsed)) seconds.\n", stderr)
     }
     return nil
 }
@@ -621,31 +944,263 @@ func wordText(for slot: Slot, state: PuzzleState) -> String {
     String(bytes: slot.cells.map { state.board[$0] ?? 63 }, encoding: .utf8) ?? ""
 }
 
+func ratio(_ part: Int, _ whole: Int) -> Double {
+    Double(part) / Double(max(whole, 1))
+}
+
+func isPartialish(_ profile: WordProfile) -> Bool {
+    let text = profile.text
+    if text.hasPrefix("INA") && profile.length >= 5 {
+        return true
+    }
+    if text.hasPrefix("IHAVE") || text.hasPrefix("WEARE") || text.hasPrefix("ITIS") || text.hasPrefix("ITSA") {
+        return true
+    }
+    if text.hasPrefix("RATED") || text.hasSuffix("IN") && profile.length >= 5 {
+        return true
+    }
+    return false
+}
+
+func weaknessReasons(for profile: WordProfile) -> [String] {
+    var reasons: [String] = []
+    let blankRatio = ratio(profile.fillBlankCount, profile.count)
+    let foreignRatio = ratio(profile.foreignLanguageClueCount, profile.count)
+
+    if profile.score < 90 {
+        reasons.append("low score \(profile.score)")
+    }
+    if profile.freshnessScore < 0 {
+        reasons.append("last seen \(profile.latestSeen ?? "unknown")")
+    }
+    if profile.length <= 4 && profile.score < 115 {
+        reasons.append("weak short fill")
+    }
+    if (5...7).contains(profile.length) && profile.count <= 8 && profile.score < 145 {
+        reasons.append("rare medium fill")
+    }
+    if profile.length >= 6 && profile.count <= 3 && profile.score < 180 {
+        reasons.append("low frequency \(profile.count)")
+    }
+    if isLowUsageFill(profile) {
+        reasons.append("low usage count \(profile.count)")
+    }
+    if isObscureShortFill(profile) {
+        reasons.append("obscure short fill")
+    }
+    if isAwkwardMediumFill(profile) {
+        reasons.append("awkward medium fill")
+    }
+    if profile.fillBlankCount >= 2 && blankRatio >= 0.5 {
+        reasons.append("fill-in clue dependent")
+    }
+    if profile.foreignLanguageClueCount >= 2 && foreignRatio >= 0.5 {
+        reasons.append("mostly foreign-language clues")
+    }
+    if profile.cluePartCount > 0 {
+        reasons.append("part-of-longer-answer clues")
+    }
+    if isThemeOrQuoteFragment(profile) {
+        reasons.append("theme/quote fragment")
+    }
+    if isNoveltyOneOff(profile) {
+        reasons.append("novelty one-off")
+    }
+    if isPartialish(profile) {
+        reasons.append("phrase fragment")
+    }
+    if let rejectionReason = profile.rejectionReason {
+        reasons.append(rejectionReason)
+    }
+    return reasons
+}
+
+func concentrationPenalty(for profiles: [WordProfile]) -> Int {
+    var weakShort = 0
+    var lowFrequencyLong = 0
+    var blankDependent = 0
+    var heavyBlankDependent = 0
+    var partialish = 0
+    var rejected = 0
+    var severeLowFrequency = 0
+    var rareMedium = 0
+    var veryWeakShort = 0
+    var lowUsageFill = 0
+    var obscureShort = 0
+    var awkwardMedium = 0
+    var themeOrQuoteFragment = 0
+    var noveltyOneOff = 0
+
+    for profile in profiles {
+        if isThemeOrQuoteFragment(profile) {
+            themeOrQuoteFragment += 1
+        }
+        if isNoveltyOneOff(profile) {
+            noveltyOneOff += 1
+        }
+        if isLowUsageFill(profile) {
+            lowUsageFill += 1
+        }
+        if isObscureShortFill(profile) {
+            obscureShort += 1
+        }
+        if isAwkwardMediumFill(profile) {
+            awkwardMedium += 1
+        }
+        if profile.length <= 4 && profile.score < 115 {
+            weakShort += 1
+        }
+        if profile.length <= 3 && profile.score < 65 {
+            veryWeakShort += 1
+        }
+        if (5...7).contains(profile.length) && profile.count <= 8 && profile.score < 145 {
+            rareMedium += 1
+        }
+        if profile.length >= 6 && profile.count <= 3 && profile.score < 180 {
+            lowFrequencyLong += 1
+        }
+        if profile.length >= 6 && profile.count <= 1 && profile.score < 180 {
+            severeLowFrequency += 1
+        }
+        if profile.fillBlankCount >= 2 && ratio(profile.fillBlankCount, profile.count) >= 0.5 {
+            blankDependent += 1
+        }
+        if profile.fillBlankCount >= 3 && ratio(profile.fillBlankCount, profile.count) >= 0.65 {
+            heavyBlankDependent += 1
+        }
+        if isPartialish(profile) {
+            partialish += 1
+        }
+        if profile.rejectionReason != nil {
+            rejected += 1
+        }
+    }
+
+    return max(0, weakShort - 6) * 85
+        + max(0, veryWeakShort - 2) * 90
+        + max(0, rareMedium - 2) * 95
+        + max(0, lowUsageFill - 4) * 90
+        + max(0, obscureShort - 1) * 170
+        + max(0, obscureShort - 3) * 130
+        + max(0, obscureShort - 6) * 120
+        + max(0, awkwardMedium - 2) * 120
+        + max(0, awkwardMedium - 5) * 90
+        + max(0, lowFrequencyLong - 3) * 80
+        + severeLowFrequency * 40
+        + themeOrQuoteFragment * 150
+        + noveltyOneOff * 75
+        + max(0, blankDependent - 1) * 110
+        + heavyBlankDependent * 80
+        + max(0, partialish - 2) * 95
+        + rejected * 150
+}
+
+func entryPenalty(for profile: WordProfile) -> Int {
+    var penalty = 0
+
+    if (5...7).contains(profile.length) && profile.score < 90 {
+        penalty += 220
+    } else if (5...7).contains(profile.length) && profile.score < 115 && profile.count <= 8 {
+        penalty += 120
+    }
+    if profile.length <= 3 && profile.score < 65 {
+        penalty += 80
+    }
+    if isLowUsageFill(profile) {
+        if profile.length <= 4 {
+            penalty += 90
+        } else if profile.length <= 5 {
+            penalty += 55
+        } else {
+            penalty += 30
+        }
+    }
+    if isThemeOrQuoteFragment(profile) {
+        penalty += 170
+    }
+    if isAwkwardMediumFill(profile) {
+        penalty += 60
+    }
+    if isNoveltyOneOff(profile) {
+        penalty += 60
+    }
+    if profile.fillBlankCount >= 3 && ratio(profile.fillBlankCount, profile.count) >= 0.65 {
+        penalty += 120
+    }
+    if profile.rejectionReason != nil {
+        penalty += 200
+    }
+
+    return penalty
+}
+
 func fillScore(state: PuzzleState, slots: [Slot], dictionary: Dictionary) -> Int {
     var score = 0
     var seen = Set<String>()
+    var profiles: [WordProfile] = []
 
     for slot in slots {
         let word = wordText(for: slot, state: state)
         score += dictionary.scoresByText[word] ?? 0
+        if let profile = dictionary.profilesByText[word] {
+            profiles.append(profile)
+            score -= entryPenalty(for: profile)
+        }
         if !seen.insert(word).inserted {
             score -= 500
         }
     }
 
-    return score
+    return score - concentrationPenalty(for: profiles)
 }
 
-func exportXD(state: PuzzleState, black: [Bool], slots: [Slot], options: Options, gridDate: String) -> String {
+func printFillReport(state: PuzzleState, slots: [Slot], dictionary: Dictionary) {
+    let profiles = slots.compactMap { dictionary.profilesByText[wordText(for: $0, state: state)] }
+    let weakEntries = profiles
+        .map { profile in (profile, weaknessReasons(for: profile)) }
+        .filter { !$0.1.isEmpty }
+        .sorted {
+            if $0.0.score != $1.0.score {
+                return $0.0.score < $1.0.score
+            }
+            return $0.0.text < $1.0.text
+        }
+        .prefix(12)
+
+    guard !weakEntries.isEmpty else {
+        fputs("Fill report: no weak entries flagged.\n", stderr)
+        return
+    }
+
+    fputs("Fill report: weakest entries\n", stderr)
+    for (profile, reasons) in weakEntries {
+        let latestSeen = profile.latestSeen ?? "unknown"
+        fputs("  \(profile.text): score \(profile.score), count \(profile.count), latest \(latestSeen), \(reasons.joined(separator: "; "))\n", stderr)
+    }
+}
+
+func repeatedAnswers(in state: PuzzleState, slots: [Slot], maxUsage: Int) -> [String: Int] {
+    var counts: [String: Int] = [:]
+
+    for slot in slots {
+        counts[wordText(for: slot, state: state), default: 0] += 1
+    }
+
+    return counts.filter { $0.value > maxUsage }
+}
+
+func exportXD(state: PuzzleState, black: [Bool], slots: [Slot], options: Options, gridIndex: Int, fillScore: Int) -> String {
     let numbers = clueNumberGrid(black: black)
     var lines: [String] = [
         "Title: \(options.title)",
-        "CmVer: 1",
+        "CmVer: 3",
         "Author: \(options.author)",
-        "Publisher: Crossmake",
+        "Publisher: Crossmate",
         "Date: \(ISO8601DateFormatter().string(from: Date()).prefix(10))",
         "Copyright: Generated",
-        "Source Grid: \(gridDate)",
+        "Grid Index: \(gridIndex)",
+        "Seed: \(options.seed)",
+        "Fill Score: \(fillScore)",
         ""
     ]
 
@@ -692,7 +1247,7 @@ func run() throws {
         qualityPath: options.qualityPath,
         badWordsPath: options.badWordsPath
     )
-    let (black, gridDate) = try loadGrid(options: options)
+    let (black, gridIndex) = try loadGrid(options: options)
     let slots = buildSlots(black: black)
     var rng = RandomNumberGenerator64(seed: options.seed)
 
@@ -703,12 +1258,22 @@ func run() throws {
         timeout: options.timeout,
         breadth: options.breadth,
         optimizeFill: options.optimizeFill,
+        maxAnswerUsages: options.maxAnswerUsages,
         rng: &rng
     ) else {
         throw GeneratorError(description: "Could not fill the grid within \(options.timeout) seconds. Try a different --seed, --grid-index, or --breadth.")
     }
+    let selectedFillScore = fillScore(state: state, slots: slots, dictionary: dictionary)
+    if let minFillScore = options.minFillScore, selectedFillScore < minFillScore {
+        throw GeneratorError(description: "Best fill score \(selectedFillScore) was below --min-fill-score \(minFillScore). Try a different --seed, --grid-index, or more timeout.")
+    }
+
+    if options.fillReport {
+        fputs("Selected fill score: \(selectedFillScore)\n", stderr)
+        printFillReport(state: state, slots: slots, dictionary: dictionary)
+    }
 
-    let xd = exportXD(state: state, black: black, slots: slots, options: options, gridDate: gridDate)
+    let xd = exportXD(state: state, black: black, slots: slots, options: options, gridIndex: gridIndex, fillScore: selectedFillScore)
     let outputURL = URL(fileURLWithPath: options.outputPath)
     let outputDirectory = outputURL.deletingLastPathComponent()
     if outputDirectory.path != "." {
@@ -721,6 +1286,6 @@ func run() throws {
 do {
     try run()
 } catch {
-    fputs("Crossmake: \(error)\n", stderr)
+    fputs("Fillmake: \(error)\n", stderr)
     exit(1)
 }

diff --git a/Crossmake/Sources/Gridmake/main.swift b/Crossmake/Sources/Gridmake/main.swift

@@ -0,0 +1,279 @@
+import Foundation
+
+let gridSize = 15
+
+struct Options {
+    var gridsPath = "Sources/Fillmake/Resources/grid_list.json"
+    var limit: Int?
+    var format = "tsv"
+}
+
+struct GridEntry: Decodable {
+    let grid: [String]
+    let date: String
+}
+
+struct Slot {
+    enum Direction: String {
+        case across
+        case down
+    }
+
+    let id: Int
+    let cells: [Int]
+    let direction: Direction
+}
+
+struct GridStats {
+    let index: Int
+    let date: String
+    let score: Int
+    let slotCount: Int
+    let openCellCount: Int
+    let threeLetterSlots: Int
+    let fourLetterSlots: Int
+    let fiveSixLetterSlots: Int
+    let sevenPlusLetterSlots: Int
+    let maxShortCluster: Int
+    let averageSlotLength: Double
+}
+
+struct GridmakeError: Error, CustomStringConvertible {
+    let description: String
+}
+
+func printUsage() {
+    print("""
+    Usage: Gridmake [options]
+
+    Options:
+      --grids PATH        Grid list JSON path. Default: Sources/Fillmake/Resources/grid_list.json
+      --limit N           Print only the top N ranked grids.
+      --format tsv|json   Output format. Default: tsv.
+      -h, --help          Show this help.
+    """)
+}
+
+func requireValue(_ arguments: [String], _ index: inout Int, _ name: String) throws -> String {
+    index += 1
+    guard index < arguments.count else {
+        throw GridmakeError(description: "Missing value for \(name)")
+    }
+    return arguments[index]
+}
+
+func parseOptions() throws -> Options {
+    var options = Options()
+    let arguments = Array(CommandLine.arguments.dropFirst())
+    var index = 0
+
+    while index < arguments.count {
+        let argument = arguments[index]
+        switch argument {
+        case "--grids":
+            options.gridsPath = try requireValue(arguments, &index, argument)
+        case "--limit":
+            let value = try requireValue(arguments, &index, argument)
+            guard let limit = Int(value), limit > 0 else {
+                throw GridmakeError(description: "--limit must be a positive integer")
+            }
+            options.limit = limit
+        case "--format":
+            let format = try requireValue(arguments, &index, argument)
+            guard ["tsv", "json"].contains(format) else {
+                throw GridmakeError(description: "--format must be tsv or json")
+            }
+            options.format = format
+        case "-h", "--help":
+            printUsage()
+            exit(0)
+        default:
+            throw GridmakeError(description: "Unknown argument: \(argument)")
+        }
+        index += 1
+    }
+
+    return options
+}
+
+func loadJSON<T: Decodable>(_ type: T.Type, from path: String) throws -> T {
+    let url = URL(fileURLWithPath: path)
+    let data = try Data(contentsOf: url)
+    return try JSONDecoder().decode(T.self, from: data)
+}
+
+func buildSlots(black: [Bool]) -> [Slot] {
+    var slots: [Slot] = []
+
+    for row in 0..<gridSize {
+        var column = 0
+        while column < gridSize {
+            let cell = row * gridSize + column
+            if black[cell] {
+                column += 1
+                continue
+            }
+            var cells: [Int] = []
+            while column < gridSize && !black[row * gridSize + column] {
+                cells.append(row * gridSize + column)
+                column += 1
+            }
+            if cells.count > 1 {
+                slots.append(Slot(id: slots.count, cells: cells, direction: .across))
+            }
+        }
+    }
+
+    for column in 0..<gridSize {
+        var row = 0
+        while row < gridSize {
+            let cell = row * gridSize + column
+            if black[cell] {
+                row += 1
+                continue
+            }
+            var cells: [Int] = []
+            while row < gridSize && !black[row * gridSize + column] {
+                cells.append(row * gridSize + column)
+                row += 1
+            }
+            if cells.count > 1 {
+                slots.append(Slot(id: slots.count, cells: cells, direction: .down))
+            }
+        }
+    }
+
+    return slots
+}
+
+func maxShortCluster(in slots: [Slot]) -> Int {
+    let shortSlotIDs = Set(slots.filter { $0.cells.count <= 4 }.map(\.id))
+    guard !shortSlotIDs.isEmpty else {
+        return 0
+    }
+
+    var cellToShortSlots: [Int: [Int]] = [:]
+    for slot in slots where shortSlotIDs.contains(slot.id) {
+        for cell in slot.cells {
+            cellToShortSlots[cell, default: []].append(slot.id)
+        }
+    }
+
+    var adjacency: [Int: Set<Int>] = [:]
+    for connectedSlots in cellToShortSlots.values where connectedSlots.count > 1 {
+        for left in connectedSlots {
+            for right in connectedSlots where right != left {
+                adjacency[left, default: []].insert(right)
+            }
+        }
+    }
+
+    var visited = Set<Int>()
+    var largest = 1
+
+    for slotID in shortSlotIDs where !visited.contains(slotID) {
+        var stack = [slotID]
+        visited.insert(slotID)
+        var size = 0
+
+        while let current = stack.popLast() {
+            size += 1
+            for next in adjacency[current, default: []] where !visited.contains(next) {
+                visited.insert(next)
+                stack.append(next)
+            }
+        }
+
+        largest = max(largest, size)
+    }
+
+    return largest
+}
+
+func stats(for entry: GridEntry, index: Int) throws -> GridStats {
+    guard entry.grid.count == gridSize * gridSize else {
+        throw GridmakeError(description: "Grid \(entry.date) has \(entry.grid.count) cells, expected \(gridSize * gridSize)")
+    }
+
+    let black = entry.grid.map { $0 == "." }
+    let slots = buildSlots(black: black)
+    let lengths = slots.map { $0.cells.count }
+    let slotCount = slots.count
+    let openCellCount = black.filter { !$0 }.count
+    let threeLetterSlots = lengths.filter { $0 == 3 }.count
+    let fourLetterSlots = lengths.filter { $0 == 4 }.count
+    let fiveSixLetterSlots = lengths.filter { (5...6).contains($0) }.count
+    let sevenPlusLetterSlots = lengths.filter { $0 >= 7 }.count
+    let shortCluster = maxShortCluster(in: slots)
+    let averageSlotLength = lengths.isEmpty ? 0 : Double(lengths.reduce(0, +)) / Double(lengths.count)
+
+    let score = sevenPlusLetterSlots * 20
+        + fiveSixLetterSlots * 8
+        - threeLetterSlots * 35
+        - fourLetterSlots * 15
+        - shortCluster * 50
+        + Int(averageSlotLength * 6)
+        - max(0, slotCount - 78) * 6
+
+    return GridStats(
+        index: index,
+        date: entry.date,
+        score: score,
+        slotCount: slotCount,
+        openCellCount: openCellCount,
+        threeLetterSlots: threeLetterSlots,
+        fourLetterSlots: fourLetterSlots,
+        fiveSixLetterSlots: fiveSixLetterSlots,
+        sevenPlusLetterSlots: sevenPlusLetterSlots,
+        maxShortCluster: shortCluster,
+        averageSlotLength: averageSlotLength
+    )
+}
+
+func printTSV(_ rankedStats: [GridStats]) {
+    print("rank\tindex\tdate\tscore\tslots\topen_cells\tlen3\tlen4\tlen5_6\tlen7_plus\tmax_short_cluster\tavg_slot_length")
+    for (rank, stats) in rankedStats.enumerated() {
+        let average = String(format: "%.2f", stats.averageSlotLength)
+        print("\(rank + 1)\t\(stats.index)\t\(stats.date)\t\(stats.score)\t\(stats.slotCount)\t\(stats.openCellCount)\t\(stats.threeLetterSlots)\t\(stats.fourLetterSlots)\t\(stats.fiveSixLetterSlots)\t\(stats.sevenPlusLetterSlots)\t\(stats.maxShortCluster)\t\(average)")
+    }
+}
+
+func jsonString(_ value: String) -> String {
+    let data = try! JSONEncoder().encode(value)
+    return String(data: data, encoding: .utf8) ?? "\"\""
+}
+
+func printJSON(_ rankedStats: [GridStats]) {
+    print("[")
+    for (offset, stats) in rankedStats.enumerated() {
+        let comma = offset == rankedStats.count - 1 ? "" : ","
+        let average = String(format: "%.4f", stats.averageSlotLength)
+        print("""
+          {"rank":\(offset + 1),"index":\(stats.index),"date":\(jsonString(stats.date)),"score":\(stats.score),"slots":\(stats.slotCount),"open_cells":\(stats.openCellCount),"len3":\(stats.threeLetterSlots),"len4":\(stats.fourLetterSlots),"len5_6":\(stats.fiveSixLetterSlots),"len7_plus":\(stats.sevenPlusLetterSlots),"max_short_cluster":\(stats.maxShortCluster),"avg_slot_length":\(average)}\(comma)
+        """)
+    }
+    print("]")
+}
+
+do {
+    let options = try parseOptions()
+    let grids = try loadJSON([GridEntry].self, from: options.gridsPath)
+    let rankedStats = try grids.enumerated()
+        .map { try stats(for: $0.element, index: $0.offset) }
+        .sorted {
+            if $0.score != $1.score {
+                return $0.score > $1.score
+            }
+            return $0.index < $1.index
+        }
+        .prefix(options.limit ?? grids.count)
+
+    if options.format == "json" {
+        printJSON(Array(rankedStats))
+    } else {
+        printTSV(Array(rankedStats))
+    }
+} catch {
+    fputs("Gridmake: \(error)\n", stderr)
+    exit(1)
+}

diff --git a/Crossmake/Sources/Pickmake/main.swift b/Crossmake/Sources/Pickmake/main.swift

@@ -0,0 +1,346 @@
+import Foundation
+
+let gridSize = 15
+let letterWeights: [UInt8: Int] = [
+    65: 9, 66: 2, 67: 2, 68: 4, 69: 12, 70: 2, 71: 3, 72: 2, 73: 9,
+    74: 1, 75: 1, 76: 4, 77: 2, 78: 6, 79: 8, 80: 2, 81: 1, 82: 6,
+    83: 4, 84: 6, 85: 4, 86: 2, 87: 2, 88: 1, 89: 2, 90: 1
+]
+
+struct Options {
+    var countsPath = "Generated/answer_counts.json"
+    var qualityPath = "Generated/word_quality.json"
+    var count = 10
+    var maxAnswerUsages = 2
+    var disallowRepeatedSelectedAnswers = false
+    var unusualScoreThreshold = 110
+    var inputs: [String] = ["Generated"]
+    var verbose = false
+}
+
+struct WordQuality: Decodable {
+    let count: Int?
+    let badClueCount: Int?
+    let obscureNameClueCount: Int?
+    let fillBlankCount: Int?
+    let rejectionReason: String?
+
+    enum CodingKeys: String, CodingKey {
+        case count
+        case badClueCount = "bad_clue_count"
+        case obscureNameClueCount = "obscure_name_clue_count"
+        case fillBlankCount = "fill_blank_count"
+        case rejectionReason = "rejection_reason"
+    }
+}
+
+struct Candidate {
+    let path: String
+    let answers: [String]
+    let counts: [String: Int]
+    let unusualAnswers: Set<String>
+    let score: Int
+}
+
+struct PickmakeError: Error, CustomStringConvertible {
+    let description: String
+}
+
+func parseOptions(_ arguments: [String]) throws -> Options {
+    var options = Options()
+    var index = 1
+    var inputs: [String] = []
+
+    func requireValue(_ name: String) throws -> String {
+        guard index + 1 < arguments.count else {
+            throw PickmakeError(description: "Missing value for \(name)")
+        }
+        index += 1
+        return arguments[index]
+    }
+
+    while index < arguments.count {
+        let arg = arguments[index]
+        switch arg {
+        case "--counts":
+            options.countsPath = try requireValue(arg)
+        case "--quality":
+            options.qualityPath = try requireValue(arg)
+        case "--count":
+            let value = try requireValue(arg)
+            guard let parsed = Int(value), parsed > 0 else {
+                throw PickmakeError(description: "--count must be a positive integer")
+            }
+            options.count = parsed
+        case "--max-answer-usages":
+            let value = try requireValue(arg)
+            guard let parsed = Int(value), parsed > 0 else {
+                throw PickmakeError(description: "--max-answer-usages must be a positive integer")
+            }
+            options.maxAnswerUsages = parsed
+        case "--disallow-all-repeats":
+            options.disallowRepeatedSelectedAnswers = true
+        case "--unusual-score-threshold":
+            let value = try requireValue(arg)
+            guard let parsed = Int(value) else {
+                throw PickmakeError(description: "--unusual-score-threshold must be an integer")
+            }
+            options.unusualScoreThreshold = parsed
+        case "--verbose":
+            options.verbose = true
+        case "--help", "-h":
+            printUsage()
+            exit(0)
+        default:
+            inputs.append(arg)
+        }
+        index += 1
+    }
+
+    if !inputs.isEmpty {
+        options.inputs = inputs
+    }
+    return options
+}
+
+func printUsage() {
+    print("""
+    Usage: Pickmake [options] [XD files or directories...]
+
+    Options:
+      --count N                       Number of puzzles to select. Default: 10
+      --counts PATH                   Answer frequency JSON path. Default: Generated/answer_counts.json
+      --quality PATH                  Word quality metadata JSON path. Default: Generated/word_quality.json
+      --max-answer-usages N           Reject puzzles using one answer more than N times. Default: 2
+      --disallow-all-repeats
+                                      Disallow any repeated answers across selected puzzles. Default: only unusual answers cannot repeat.
+      --unusual-score-threshold N     Answers scoring below N cannot repeat across selected puzzles. Default: 110
+      --verbose                       Print rejected puzzle details to stderr.
+      -h, --help                      Show this help.
+    """)
+}
+
+func loadJSON<T: Decodable>(_ type: T.Type, from path: String) throws -> T {
+    let data = try Data(contentsOf: URL(fileURLWithPath: path))
+    return try JSONDecoder().decode(T.self, from: data)
+}
+
+func vowelCount(_ bytes: [UInt8]) -> Int {
+    bytes.filter { $0 == 65 || $0 == 69 || $0 == 73 || $0 == 79 || $0 == 85 }.count
+}
+
+func hasRunOfThree(_ bytes: [UInt8]) -> Bool {
+    guard bytes.count >= 3 else {
+        return false
+    }
+    for index in 2..<bytes.count where bytes[index] == bytes[index - 1] && bytes[index] == bytes[index - 2] {
+        return true
+    }
+    return false
+}
+
+func qualityScore(text: String, count: Int?, quality: WordQuality?) -> Int {
+    let bytes = Array(text.utf8)
+    let length = bytes.count
+    let frequency = count ?? 0
+    var score = length * 12
+
+    if frequency > 0 {
+        score += min(80, frequency * 4)
+    } else {
+        score -= length >= 8 ? 30 : 80
+    }
+
+    if length >= 8 {
+        score += min(80, (length - 7) * 14)
+    }
+    if (5...7).contains(length) && frequency <= 2 {
+        score -= 70
+    }
+    if length == 4 && frequency < 10 {
+        score -= 60
+    }
+    if length <= 3 && frequency < 25 {
+        score -= 80
+    }
+
+    let vowels = vowelCount(bytes)
+    if vowels == 0 {
+        score -= 90
+    } else if length >= 5 && Double(vowels) / Double(length) < 0.22 {
+        score -= 35
+    }
+    if hasRunOfThree(bytes) {
+        score -= 110
+    }
+
+    if let quality {
+        let evidenceCount = max(quality.count ?? frequency, 1)
+        let badRatio = Double(quality.badClueCount ?? 0) / Double(evidenceCount)
+        let obscureRatio = Double(quality.obscureNameClueCount ?? 0) / Double(evidenceCount)
+        let blankRatio = Double(quality.fillBlankCount ?? 0) / Double(evidenceCount)
+
+        if quality.rejectionReason != nil {
+            score -= length >= 8 ? 80 : 140
+        }
+        if length <= 4 {
+            score -= Int(badRatio * 100)
+            score -= Int(obscureRatio * 70)
+            score -= Int(blankRatio * 45)
+        } else if length <= 7 {
+            score -= Int(badRatio * 45)
+            score -= Int(obscureRatio * 35)
+            score -= Int(blankRatio * 20)
+        } else {
+            score -= Int(badRatio * 20)
+            score -= Int(obscureRatio * 15)
+        }
+    }
+
+    return score + bytes.reduce(0) { $0 + (letterWeights[$1] ?? 0) }
+}
+
+func discoverXDPaths(inputs: [String]) throws -> [String] {
+    let fileManager = FileManager.default
+    var paths: [String] = []
+
+    for input in inputs {
+        var isDirectory: ObjCBool = false
+        guard fileManager.fileExists(atPath: input, isDirectory: &isDirectory) else {
+            throw PickmakeError(description: "Input not found: \(input)")
+        }
+
+        if isDirectory.boolValue {
+            let url = URL(fileURLWithPath: input)
+            guard let enumerator = fileManager.enumerator(at: url, includingPropertiesForKeys: [.isRegularFileKey]) else {
+                continue
+            }
+            for case let fileURL as URL in enumerator where fileURL.pathExtension.lowercased() == "xd" {
+                paths.append(fileURL.path)
+            }
+        } else if input.lowercased().hasSuffix(".xd") {
+            paths.append(URL(fileURLWithPath: input).path)
+        }
+    }
+
+    return Array(Set(paths)).sorted()
+}
+
+func answers(in path: String) throws -> [String] {
+    let contents = try String(contentsOfFile: path, encoding: .utf8)
+    return contents.split(separator: "\n").compactMap { line in
+        guard let separator = line.range(of: " ~ ") else {
+            return nil
+        }
+        let answer = line[separator.upperBound...].trimmingCharacters(in: .whitespaces)
+        guard !answer.isEmpty, answer.allSatisfy({ $0 >= "A" && $0 <= "Z" }) else {
+            return nil
+        }
+        return answer
+    }
+}
+
+func storedFillScore(in path: String) throws -> Int? {
+    let contents = try String(contentsOfFile: path, encoding: .utf8)
+    for line in contents.split(separator: "\n") {
+        guard line.hasPrefix("Fill Score:") else {
+            continue
+        }
+        let value = line.dropFirst("Fill Score:".count).trimmingCharacters(in: .whitespaces)
+        return Int(value)
+    }
+    return nil
+}
+
+func makeCandidate(path: String, counts: [String: Int], quality: [String: WordQuality], unusualScoreThreshold: Int) throws -> Candidate {
+    let words = try answers(in: path)
+    let answerCounts = Dictionary(grouping: words, by: { $0 }).mapValues(\.count)
+    var unusual = Set<String>()
+    var score = 0
+
+    for word in words {
+        let key = word.lowercased()
+        let wordScore = qualityScore(text: word, count: counts[key], quality: quality[key])
+        score += wordScore
+        if wordScore < unusualScoreThreshold {
+            unusual.insert(word)
+        }
+    }
+
+    return Candidate(path: path, answers: words, counts: answerCounts, unusualAnswers: unusual, score: try storedFillScore(in: path) ?? score)
+}
+
+func run() throws {
+    let options = try parseOptions(CommandLine.arguments)
+    let counts = try loadJSON([String: Int].self, from: options.countsPath)
+    let quality = try loadJSON([String: WordQuality].self, from: options.qualityPath)
+    let paths = try discoverXDPaths(inputs: options.inputs)
+    let candidates = try paths.map {
+        try makeCandidate(path: $0, counts: counts, quality: quality, unusualScoreThreshold: options.unusualScoreThreshold)
+    }.sorted {
+        if $0.score != $1.score {
+            return $0.score > $1.score
+        }
+        return $0.path < $1.path
+    }
+
+    var selected: [Candidate] = []
+    var selectedUnusual = Set<String>()
+    var selectedAnswers = Set<String>()
+    var rejectedForInternalRepeats = 0
+    var rejectedForAnswerRepeats = 0
+    var rejectedForUnusualRepeats = 0
+
+    for candidate in candidates {
+        let overused = candidate.counts
+            .filter { $0.value > options.maxAnswerUsages }
+            .sorted { $0.key < $1.key }
+        if !overused.isEmpty {
+            rejectedForInternalRepeats += 1
+            if options.verbose {
+                let details = overused.map { "\($0.key)=\($0.value)" }.joined(separator: ", ")
+                fputs("Rejected \(candidate.path): answer usage > \(options.maxAnswerUsages) (\(details))\n", stderr)
+            }
+            continue
+        }
+        let repeatedAnswers = Set(candidate.answers).intersection(selectedAnswers).sorted()
+        if options.disallowRepeatedSelectedAnswers && !repeatedAnswers.isEmpty {
+            rejectedForAnswerRepeats += 1
+            if options.verbose {
+                fputs("Rejected \(candidate.path): repeated selected answers (\(repeatedAnswers.joined(separator: ", ")))\n", stderr)
+            }
+            continue
+        }
+        if !options.disallowRepeatedSelectedAnswers {
+            let repeatedUnusual = candidate.unusualAnswers.intersection(selectedUnusual).sorted()
+            if !repeatedUnusual.isEmpty {
+                rejectedForUnusualRepeats += 1
+                if options.verbose {
+                    fputs("Rejected \(candidate.path): repeated unusual answers (\(repeatedUnusual.joined(separator: ", ")))\n", stderr)
+                }
+                continue
+            }
+        }
+
+        selected.append(candidate)
+        selectedAnswers.formUnion(candidate.answers)
+        selectedUnusual.formUnion(candidate.unusualAnswers)
+        if selected.count == options.count {
+            break
+        }
+    }
+
+    for candidate in selected {
+        print(candidate.path)
+    }
+
+    fputs("Selected \(selected.count) of \(options.count) requested puzzles from \(candidates.count) candidates.\n", stderr)
+    fputs("Rejected \(rejectedForInternalRepeats) for answer usage > \(options.maxAnswerUsages); \(rejectedForAnswerRepeats) for repeated selected answers; \(rejectedForUnusualRepeats) for repeated unusual answers below score \(options.unusualScoreThreshold).\n", stderr)
+}
+
+do {
+    try run()
+} catch {
+    fputs("Pickmake: \(error)\n", stderr)
+    exit(1)
+}

diff --git a/Crossmake/Sources/Wordmake/main.swift b/Crossmake/Sources/Wordmake/main.swift

@@ -91,6 +91,10 @@ struct AnswerEvidence {
     var obscureNameClueCount = 0
     var fillBlankCount = 0
     var foreignLanguageClueCount = 0
+    var cluePartCount = 0
+    var continuationClueCount = 0
+    var themeClueCount = 0
+    var latestSeen: String?
     var sampleClues: [String] = []
 }
 
@@ -99,17 +103,26 @@ struct WordmakeError: Error, CustomStringConvertible {
 }
 
 let badClueRegex = try! NSRegularExpression(
-    pattern: #"\b(abbr|var|prefix|suffix|archaic|poetic|dial|slang|obs|old-style|old fashioned|scot|irish|brit|fr|french|ger|german|lat|latin|span|spanish|ital|italian|port|portuguese|hebr|hebrew|yiddish|jap|japanese|inits|initials|letters|compass point|bearing|direction|shoe width|monogram|degs|degree|of yore|old|olden|heraldry|genus|legal|in law|anatomical|serf|serfs|slave|slaves|vassal|pilaster|opera voices|persian fairy|mideast|eastern v\.?i\.?p|arab prince|arab chieftain|hindu title|indian princess|rajah|dirk|knife of old|seed covering|seed casing|seed envelope|hip bones|pelvic bones|bitter vetch|marsh birds)\b"#,
+    pattern: #"\b(abbr|var|prefix|suffix|comb\.? form|archaic|poetic|dial|slang|obs|old-style|old fashioned|scot|irish|brit|fr|french|ger|german|lat|latin|span|spanish|ital|italian|port|portuguese|hebr|hebrew|yiddish|jap|japanese|inits|initials|letters|compass point|bearing|direction|shoe width|monogram|degs|degree|of yore|old|olden|heraldry|genus|legal|in law|anatomical|serf|serfs|slave|slaves|vassal|pilaster|opera voices|persian fairy|mideast|eastern v\.?i\.?p|arab prince|arab chieftain|hindu title|indian princess|rajah|dirk|knife of old|seed covering|seed casing|seed envelope|hip bones|pelvic bones|bitter vetch|marsh birds)\b"#,
     options: [.caseInsensitive]
 )
 let obscureNameClueRegex = try! NSRegularExpression(
-    pattern: #"\b(actor|actress|author|composer|singer|poet|novelist|painter|artist|playwright|violinist|pianist|conductor|golfer|pitcher|baseballer|songwriter|politician|senator|governor)\b"#,
+    pattern: #"\b(actor|actress|author|composer|singer|poet|novelist|painter|artist|playwright|violinist|pianist|conductor|golfer|pitcher|baseballer|songwriter|politician|senator|governor|pope)\b"#,
     options: [.caseInsensitive]
 )
 let fillBlankRegex = try! NSRegularExpression(pattern: #"_{2,}|\.{3,}"#)
 let foreignLanguageClueRegex = try! NSRegularExpression(
     pattern: #":\s*(?:Sp|Span|Fr|Ger|Germ|It|Ital|Lat|Port|Heb|Yid|Jap|Rus|Gr|Gk|Swed|Norw|Dan|Arab|Chin|Hind|Skt|Turk|Finn)\.|,\s+in\s+[A-Z][a-z]"#
 )
+let cluePartRegex = try! NSRegularExpression(
+    pattern: #"\b(?:part|section|segment|installment)\s+\d+\b|\b\d+(?:st|nd|rd|th)\s+(?:part|section|segment|installment)\b"#,
+    options: [.caseInsensitive]
+)
+let continuationClueRegex = try! NSRegularExpression(
+    pattern: #"\b(?:end|start|middle|continuation)\s+of\s+(?:the\s+)?(?:quote|quip|remark|saying|joke)\b|^see\s+\d+"#,
+    options: [.caseInsensitive]
+)
+let themeClueRegex = try! NSRegularExpression(pattern: #"^\s*\*"#)
 let clueNumberRegex = try! NSRegularExpression(pattern: #"^\s*\d+\.\s*"#)
 let datePathRegex = try! NSRegularExpression(pattern: #"(\d{4})/(\d{2})/(\d{2})\.json$"#)
 
@@ -345,6 +358,20 @@ func weekdayForPath(_ url: URL) -> Int? {
     return (calendarWeekday + 5) % 7
 }
 
+func isoDateForPath(_ url: URL) -> String? {
+    let path = url.path.replacingOccurrences(of: "\\", with: "/")
+    let range = NSRange(path.startIndex..<path.endIndex, in: path)
+    guard let match = datePathRegex.firstMatch(in: path, range: range),
+          match.numberOfRanges == 4,
+          let yearRange = Range(match.range(at: 1), in: path),
+          let monthRange = Range(match.range(at: 2), in: path),
+          let dayRange = Range(match.range(at: 3), in: path) else {
+        return nil
+    }
+
+    return "\(path[yearRange])-\(path[monthRange])-\(path[dayRange])"
+}
+
 func puzzleWeekday(_ puzzle: Any, path: URL) -> Int? {
     if let puzzle = puzzle as? [String: Any],
        let dow = puzzle["dow"] as? String,
@@ -404,6 +431,103 @@ func clueRatio(_ part: Int, _ whole: Int) -> Double {
     Double(part) / Double(max(whole, 1))
 }
 
+func hasSequentialLetterRun(_ word: String, minimumLength: Int = 4) -> Bool {
+    let scalars = word.unicodeScalars.map(\.value)
+    guard scalars.count >= minimumLength else {
+        return false
+    }
+
+    var runLength = 1
+    for index in 1..<scalars.count {
+        if scalars[index] == scalars[index - 1] + 1 {
+            runLength += 1
+            if runLength >= minimumLength {
+                return true
+            }
+        } else {
+            runLength = 1
+        }
+    }
+    return false
+}
+
+func isInitialSurnameArtifact(_ word: String) -> Bool {
+    let fusedNames: Set<String> = [
+        "ed", "ek", "el", "em", "et",
+        "jk", "jl", "jr",
+        "kd", "kt",
+        "mj",
+        "oj",
+        "tj",
+        "wc"
+    ]
+
+    return fusedNames.contains { word.hasPrefix($0) && word.count >= 6 }
+}
+
+func isPhraseFragmentArtifact(_ word: String, fillBlankRatio: Double) -> Bool {
+    guard word.count >= 5 else {
+        return false
+    }
+    let prefixes = [
+        "aan", "aand", "anold", "asof", "ated", "cani",
+        "cular",
+        "igota", "igot", "imeta", "imet", "ihave", "itisa", "itwas",
+        "weare", "youre"
+    ]
+    if prefixes.contains(where: { word.hasPrefix($0) }) {
+        return true
+    }
+    if word.count >= 10 {
+        return fillBlankRatio >= 0.8
+    }
+    return fillBlankRatio >= 0.8 && word.count <= 7
+}
+
+func isVerySuspiciousOneOff(_ word: String, evidence: AnswerEvidence) -> Bool {
+    guard word.count >= 8, evidence.count == 1, evidence.latestSeen != nil else {
+        return false
+    }
+    if evidence.obscureNameClueCount > 0 {
+        return true
+    }
+    if word.hasSuffix("c") || word.hasSuffix("v") || word.hasSuffix("x") {
+        return true
+    }
+    return false
+}
+
+func isStaleOneOffLongFill(_ word: String, evidence: AnswerEvidence) -> Bool {
+    guard word.count >= 8,
+          evidence.count == 1,
+          let latestSeen = evidence.latestSeen else {
+        return false
+    }
+    return latestSeen < "2000-01-01"
+}
+
+func isPunnyOneOff(_ word: String, evidence: AnswerEvidence) -> Bool {
+    guard word.count >= 8, evidence.count == 1 else {
+        return false
+    }
+    return evidence.sampleClues.contains { $0.contains("?") }
+}
+
+func stricterShortRequiredCount(_ word: String) -> Int? {
+    switch word.count {
+    case ...2:
+        return nil
+    case 3:
+        return 25
+    case 4:
+        return 12
+    case 5:
+        return 6
+    default:
+        return nil
+    }
+}
+
 func easyRejectionReason(word: String, evidence: AnswerEvidence) -> String? {
     let length = word.count
     let count = evidence.count
@@ -412,12 +536,78 @@ func easyRejectionReason(word: String, evidence: AnswerEvidence) -> String? {
         return nil
     }
 
+    if crosswordeseWords.contains(word) {
+        return "known crosswordese/glue fill"
+    }
+
+    let badRatio = clueRatio(evidence.badClueCount, count)
+    let obscureNameRatio = clueRatio(evidence.obscureNameClueCount, count)
+    let fillBlankRatio = clueRatio(evidence.fillBlankCount, count)
+    let foreignLanguageRatio = clueRatio(evidence.foreignLanguageClueCount, count)
+    let cluePartRatio = clueRatio(evidence.cluePartCount, count)
+
     if count < easyRequiredCount(word) {
         return "count \(count) below easy threshold \(easyRequiredCount(word))"
     }
 
-    if crosswordeseWords.contains(word) {
-        return "known crosswordese/glue fill"
+    if let stricterCount = stricterShortRequiredCount(word),
+       !commonShortWords.contains(word),
+       count < stricterCount {
+        return "short entry count \(count) below generated-fill threshold \(stricterCount)"
+    }
+
+    if length <= 5 && count < 80 && evidence.badClueCount >= 2 && badRatio >= 0.35 {
+        return "short entry mostly clued as abbreviation/variant/form"
+    }
+
+    if length <= 5 &&
+       !commonShortWords.contains(word),
+       evidence.latestSeen.map({ $0 < "2000-01-01" }) == true {
+        return "stale short fill"
+    }
+
+    if hasSequentialLetterRun(word) {
+        return "alphabet-run artifact"
+    }
+
+    if length >= 5 && !hasVowel(word) {
+        return "long entry with no vowel"
+    }
+
+    if isInitialSurnameArtifact(word) {
+        return "initial-plus-name artifact"
+    }
+
+    if isPhraseFragmentArtifact(word, fillBlankRatio: fillBlankRatio) {
+        return "phrase fragment artifact"
+    }
+
+    if evidence.themeClueCount > 0 && (count <= 2 || clueRatio(evidence.themeClueCount, count) >= 0.5) {
+        return "one-off theme clue artifact"
+    }
+
+    if evidence.continuationClueCount > 0 && (count <= 3 || clueRatio(evidence.continuationClueCount, count) >= 0.5) {
+        return "cross-reference or quote-continuation artifact"
+    }
+
+    if isStaleOneOffLongFill(word, evidence: evidence) {
+        return "stale one-off long fill"
+    }
+
+    if isVerySuspiciousOneOff(word, evidence: evidence) {
+        return "one-off long artifact"
+    }
+
+    if isPunnyOneOff(word, evidence: evidence) {
+        return "one-off pun/theme artifact"
+    }
+
+    if length <= 5 && evidence.badClueCount >= 2 && badRatio >= 0.45 {
+        return "entry mostly clued as abbreviation/variant/form"
+    }
+
+    if length <= 5 && evidence.obscureNameClueCount >= 2 && obscureNameRatio >= 0.5 {
+        return "short entry mostly clued as obscure name/title"
     }
 
     if length <= 4 && commonShortWords.contains(word) {
@@ -436,10 +626,9 @@ func easyRejectionReason(word: String, evidence: AnswerEvidence) -> String? {
         return "short suffix-like fragment"
     }
 
-    let badRatio = clueRatio(evidence.badClueCount, count)
-    let obscureNameRatio = clueRatio(evidence.obscureNameClueCount, count)
-    let fillBlankRatio = clueRatio(evidence.fillBlankCount, count)
-    let foreignLanguageRatio = clueRatio(evidence.foreignLanguageClueCount, count)
+    if evidence.cluePartCount > 0 && (count <= 3 || cluePartRatio >= 0.5) {
+        return "entry mostly clued as one part of a longer answer"
+    }
 
     if length <= 5 &&
         evidence.foreignLanguageClueCount >= 2 &&
@@ -502,10 +691,16 @@ func loadAnswerEvidence(inputURL: URL, options: Options) throws -> (evidence: [S
             guard shouldIncludePuzzle(puzzle, path: path, weekdays: options.weekdays) else {
                 continue
             }
+            let latestSeen = isoDateForPath(path)
             filesUsed += 1
             for (answer, clue) in normalizedEntries(from: puzzle) where shouldInclude(answer, minLength: options.minLength, maxLength: options.maxLength) {
                 var entry = evidence[answer] ?? AnswerEvidence()
                 entry.count += 1
+                if let latestSeen {
+                    if entry.latestSeen.map({ latestSeen > $0 }) ?? true {
+                        entry.latestSeen = latestSeen
+                    }
+                }
                 if entry.sampleClues.count < 5 && !clue.isEmpty {
                     entry.sampleClues.append(clue)
                 }
@@ -521,6 +716,15 @@ func loadAnswerEvidence(inputURL: URL, options: Options) throws -> (evidence: [S
                 if regexMatches(foreignLanguageClueRegex, clue) {
                     entry.foreignLanguageClueCount += 1
                 }
+                if regexMatches(cluePartRegex, clue) {
+                    entry.cluePartCount += 1
+                }
+                if regexMatches(continuationClueRegex, clue) {
+                    entry.continuationClueCount += 1
+                }
+                if regexMatches(themeClueRegex, clue) {
+                    entry.themeClueCount += 1
+                }
                 evidence[answer] = entry
             }
         } catch {
@@ -556,6 +760,10 @@ func evidenceObject(_ entry: AnswerEvidence, rejectionReason: String?) -> [Strin
         "obscure_name_clue_count": entry.obscureNameClueCount,
         "fill_blank_count": entry.fillBlankCount,
         "foreign_language_clue_count": entry.foreignLanguageClueCount,
+        "clue_part_count": entry.cluePartCount,
+        "continuation_clue_count": entry.continuationClueCount,
+        "theme_clue_count": entry.themeClueCount,
+        "latest_seen": entry.latestSeen as Any? ?? NSNull(),
         "sample_clues": entry.sampleClues,
         "rejection_reason": rejectionReason as Any? ?? NSNull()
     ]
@@ -569,6 +777,10 @@ func rejectionObject(reason: String, entry: AnswerEvidence) -> [String: Any] {
         "obscure_name_clue_count": entry.obscureNameClueCount,
         "fill_blank_count": entry.fillBlankCount,
         "foreign_language_clue_count": entry.foreignLanguageClueCount,
+        "clue_part_count": entry.cluePartCount,
+        "continuation_clue_count": entry.continuationClueCount,
+        "theme_clue_count": entry.themeClueCount,
+        "latest_seen": entry.latestSeen as Any? ?? NSNull(),
         "sample_clues": entry.sampleClues
     ]
 }