honeytree 1.1.2 → 1.1.4

package/bin/honeydew.js

@@ -1,6 +1,18 @@
 #!/usr/bin/env node
 
+import path from "node:path";
+
 const command = process.argv[2];
+const invokedAs = path.basename(process.argv[1] || "honeytree");
+
+function printUsage() {
+  console.error("Usage:");
+  console.error("  honeytree          show your forest");
+  console.error("  honeytree init     create or migrate your forest");
+  console.error("  honeytree watch    open the terminal forest");
+  console.error("  honeytree stats    show a non-TUI summary");
+  console.error("  honeytree export   write honeytree-badge.svg and FOREST.md");
+}
 
 if (command === "init") {
   const { init } = await import("../src/commands/init.js");
@@ -11,11 +23,17 @@ if (command === "init") {
 } else if (command === "watch" || !command) {
   const { watch } = await import("../src/commands/watch.js");
   await watch();
+} else if (command === "stats") {
+  const { stats } = await import("../src/commands/stats.js");
+  await stats();
 } else if (command === "plant") {
   const { plant } = await import("../src/commands/plant.js");
   await plant();
 } else {
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: honeytree [init | export | watch]");
+  if (invokedAs === "honeydew") {
+    console.error("Run `honeydew watch` or `honeytree init`.");
+  }
+  printUsage();
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeytree",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "A living pixel art forest that grows while you code",
   "type": "module",
   "bin": {

package/src/commands/watch.js

@@ -2,14 +2,18 @@ import React, { useEffect, useMemo, useState } from "react";
 import { Box, Text, render, useApp, useInput, useStdout } from "ink";
 
 import { applyActiveMinutes, applyCommit, applyFileSave } from "../core/progression.js";
+import { detectBiome } from "../core/biomeDetector.js";
+import { migrateTreesToBiome } from "../core/biomeMigration.js";
+import { classifyDiffStat, classifyFileList, parseDiffStatLine, updateSessionWindow } from "../core/sessionDetector.js";
 import { ensureState, readState, updateState } from "../core/state.js";
 import { renderTerminalFrame } from "../renderers/terminal.js";
 import { createActivityTracker } from "../tracker/activity.js";
 import { startFileTracker } from "../tracker/files.js";
 import { startGitTracker } from "../tracker/git.js";
 
-const FRAME_MS = 100;
-const POLL_MS = 1_000;
+const FRAME_MS = 150;
+const STATE_SYNC_MS = 1_000;
+const GIT_POLL_MS = 30_000;
 const h = React.createElement;
 
 function buildCommandHint(width) {
@@ -29,6 +33,8 @@ function ForestWatchApp() {
   const [width, setWidth] = useState(stdout.columns || 80);
   const [height, setHeight] = useState(stdout.rows || 24);
 
+  const sessionWindow = useMemo(() => [], []);
+
   useInput((input, key) => {
     if (input === "q" || key.escape || key.ctrl && input === "c") {
       exit();
@@ -57,7 +63,7 @@ function ForestWatchApp() {
       if (latest) {
         setState(latest);
       }
-    }, POLL_MS);
+    }, STATE_SYNC_MS);
     return () => clearInterval(syncTimer);
   }, []);
 
@@ -82,9 +88,33 @@ function ForestWatchApp() {
     const gitTracker = startGitTracker({
       cwd: process.cwd(),
       lastCommitHash: state.last_commit_hash,
+      pollMs: GIT_POLL_MS,
       async onCommit(commitHash) {
         const nextState = updateState((draft) => applyCommit(draft, { commitHash }));
         setState(nextState);
+
+        // Session detection: classify this commit
+        try {
+          const git = (await import("simple-git")).default({ baseDir: process.cwd() });
+          const diffStat = await git.diff(["--stat", "HEAD~1..HEAD"]);
+          const diffFiles = await git.diff(["--name-only", "HEAD~1..HEAD"]);
+          const statLine = diffStat.split("\n").filter((l) => l.includes("changed")).pop() || "";
+          const parsed = parseDiffStatLine(statLine);
+          const fileList = diffFiles.split("\n").filter(Boolean);
+          const fileInfo = classifyFileList(fileList);
+          const sessionType = classifyDiffStat({ ...parsed, ...fileInfo });
+
+          sessionWindow.push(sessionType);
+          if (sessionWindow.length > 5) sessionWindow.shift();
+
+          const activeSession = updateSessionWindow(sessionWindow);
+          updateState((draft) => {
+            draft.activeSession = activeSession;
+            return draft;
+          });
+        } catch {
+          // Session detection failure is non-critical
+        }
       },
     });
 
@@ -112,6 +142,17 @@ function ForestWatchApp() {
 }
 
 export async function watch() {
+  // Detect and persist biome on startup, migrating trees if biome changed
+  updateState((draft) => {
+    const previousBiome = draft.biome || "general";
+    const detected = detectBiome(process.cwd());
+    if (draft.biome !== detected) {
+      draft.trees = migrateTreesToBiome(draft.trees, previousBiome, detected);
+      draft.biome = detected;
+    }
+    return draft;
+  });
+
   ensureState();
   const app = render(h(ForestWatchApp));
   await app.waitUntilExit();

package/src/core/biomeDetector.js

@@ -0,0 +1,126 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const EXTENSION_MAP = {
+  frontend: new Set([".tsx", ".jsx", ".vue", ".svelte", ".css", ".scss", ".sass", ".less", ".html", ".ejs"]),
+  backend: new Set([".py", ".java", ".go", ".rs", ".rb", ".php", ".cs", ".scala", ".kt", ".ex", ".exs"]),
+  aiml: new Set([".ipynb", ".onnx", ".pkl", ".h5", ".safetensors"]),
+  infra: new Set([".tf", ".yaml", ".yml", ".toml", ".sh", ".bash", ".nix", ".hcl"]),
+  docs: new Set([".md", ".mdx", ".rst", ".txt", ".adoc", ".wiki"]),
+};
+
+const INFRA_BASENAMES = new Set(["Dockerfile", "Makefile", "docker-compose.yml", "docker-compose.yaml"]);
+
+const ML_DEPS = ["torch", "tensorflow", "transformers", "sklearn", "pandas", "numpy"];
+
+const THRESHOLD = 0.4;
+
+function categorizeFile(filePath) {
+  const basename = path.basename(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+
+  if (INFRA_BASENAMES.has(basename)) return "infra";
+
+  for (const [category, extensions] of Object.entries(EXTENSION_MAP)) {
+    if (extensions.has(ext)) return category;
+  }
+
+  return null;
+}
+
+export function classifyFiles(filePaths) {
+  const counts = { frontend: 0, backend: 0, aiml: 0, infra: 0, docs: 0 };
+  let hasNotebook = false;
+
+  for (const filePath of filePaths) {
+    const category = categorizeFile(filePath);
+    if (category) {
+      counts[category] += 1;
+    }
+    if (path.extname(filePath).toLowerCase() === ".ipynb") {
+      hasNotebook = true;
+    }
+  }
+
+  // AI/ML special case: .py in model/train/data dirs + notebook presence
+  if (hasNotebook && counts.backend > 0) {
+    counts.aiml += counts.backend;
+    counts.backend = 0;
+  }
+
+  const total = Object.values(counts).reduce((sum, n) => sum + n, 0);
+  if (total === 0) return "general";
+
+  let best = "general";
+  let bestPct = 0;
+  for (const [category, count] of Object.entries(counts)) {
+    const pct = count / total;
+    if (pct > bestPct) {
+      bestPct = pct;
+      best = category;
+    }
+  }
+
+  return bestPct > THRESHOLD ? best : "general";
+}
+
+function walkDir(dir) {
+  const results = [];
+  const SKIP_DIRS = new Set(["node_modules", ".git", ".honeytree", ".honeydew", "dist", "build", "__pycache__", ".next", ".vscode"]);
+
+  function recurse(currentDir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.isDirectory()) continue;
+      if (SKIP_DIRS.has(entry.name) && entry.isDirectory()) continue;
+
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        recurse(fullPath);
+      } else {
+        results.push(path.relative(dir, fullPath));
+      }
+    }
+  }
+
+  recurse(dir);
+  return results;
+}
+
+function checkMlDeps(repoDir) {
+  const candidates = ["requirements.txt", "pyproject.toml"];
+  for (const candidate of candidates) {
+    const filePath = path.join(repoDir, candidate);
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      if (ML_DEPS.some((dep) => content.includes(dep))) {
+        return true;
+      }
+    } catch {
+      // file doesn't exist, skip
+    }
+  }
+  return false;
+}
+
+export function detectBiome(repoDir = process.cwd()) {
+  const files = walkDir(repoDir);
+  const hasMlDeps = checkMlDeps(repoDir);
+
+  if (hasMlDeps) {
+    const adjusted = files.map((f) => {
+      if (path.extname(f) === ".py") {
+        return f.replace(/\.py$/, ".ipynb");
+      }
+      return f;
+    });
+    return classifyFiles(adjusted);
+  }
+
+  return classifyFiles(files);
+}

package/src/core/biomeMigration.js

@@ -0,0 +1,22 @@
+import { getBiomeConfig } from "./biomes/index.js";
+
+function findTierIndex(species, biomeKey) {
+  const config = getBiomeConfig(biomeKey);
+  return config.trees.findIndex((t) => t.species === species);
+}
+
+export function migrateTreesToBiome(trees, fromBiome, toBiome) {
+  if (fromBiome === toBiome) return trees;
+
+  const toConfig = getBiomeConfig(toBiome);
+
+  return trees.map((tree) => {
+    if (tree.species === "crystal_tree") return tree;
+
+    const tierIndex = findTierIndex(tree.species, fromBiome);
+    if (tierIndex === -1) return tree; // unknown species, leave as-is
+
+    const newSpecies = toConfig.trees[tierIndex]?.species ?? tree.species;
+    return { ...tree, species: newSpecies };
+  });
+}

package/src/core/biomes/aiml.js

@@ -0,0 +1,36 @@
+export const aimlBiome = {
+  key: "aiml",
+  name: "Bioluminescent Grove",
+
+  trees: [
+    { species: "spore",           minCommits: 1,   maxCommits: 2 },
+    { species: "glowstem",        minCommits: 3,   maxCommits: 8 },
+    { species: "crystal_sapling", minCommits: 9,   maxCommits: 18 },
+    { species: "mycelium_tree",   minCommits: 19,  maxCommits: 30 },
+    { species: "neural_oak",      minCommits: 31,  maxCommits: 45 },
+    { species: "void_willow",     minCommits: 46,  maxCommits: 65 },
+    { species: "ancient_node",    minCommits: 66,  maxCommits: 100 },
+    { species: "crystal_tree",    minCommits: 101, maxCommits: Infinity },
+  ],
+
+  groundElements: ["glowing_mushroom", "crystal_shard", "spore_pod", "root_cluster"],
+  animals: ["firefly", "moth", "chameleon", "fox", "spirit_owl"],
+
+  palette: {
+    leaf: "#0a3a4a", leafDark: "#0a2a30", leafLight: "#1a4a5a",
+    trunk: "#3a2a48", trunkDark: "#1a1028", trunkLight: "#4a3a58",
+    ground: "#0a1a10", groundDark: "#060e06", groundLight: "#0a2018",
+    grass: "#0a1a10", grassLight: "#1a2a18",
+  },
+
+  sky: { top: "#060618", mid: "#0a0a28", bottom: "#0a1020" },
+
+  ground: {
+    grass: ["#0a1a10", "#0a180a", "#081408"],
+    dirt: ["#0a0a10", "#080810", "#060608"],
+  },
+
+  particles: ["fireflies", "drifting_spores"],
+  bushes: ["spore_cluster", "glow_moss", "mycelium_web"],
+  undergrowthDensity: 0.5,
+};

package/src/core/biomes/backend.js

@@ -0,0 +1,35 @@
+export const backendBiome = {
+  key: "backend",
+  name: "Deep Woods",
+
+  trees: [
+    { species: "seedling",      minCommits: 1,   maxCommits: 2 },
+    { species: "thin_birch",    minCommits: 3,   maxCommits: 8 },
+    { species: "tall_pine",     minCommits: 9,   maxCommits: 18 },
+    { species: "dark_oak",      minCommits: 19,  maxCommits: 30 },
+    { species: "dense_spruce",  minCommits: 31,  maxCommits: 45 },
+    { species: "moss_oak",      minCommits: 46,  maxCommits: 65 },
+    { species: "ancient_pine",  minCommits: 66,  maxCommits: 100 },
+    { species: "crystal_tree",  minCommits: 101, maxCommits: Infinity },
+  ],
+
+  groundElements: ["fern", "moss_patch", "old_log", "bracket_fungus"],
+  animals: ["beetle", "frog", "rabbit", "owl", "wolf"],
+
+  palette: {
+    leaf: "#1a4a20", leafDark: "#0a3010", leafLight: "#2a5a30",
+    ground: "#0f1a0a", groundDark: "#0a1205", groundLight: "#1a2a10",
+    grass: "#1a4a1a", grassLight: "#2a5a2a",
+  },
+
+  sky: { top: "#1a2a1a", mid: "#152518", bottom: "#0f1f10" },
+
+  ground: {
+    grass: ["#1a4a1a", "#183a18", "#143014"],
+    dirt: ["#2a2018", "#1a1810", "#141008"],
+  },
+
+  particles: ["fog_wisps"],
+  bushes: ["fern_cluster", "moss_mound", "root_tangle"],
+  undergrowthDensity: 0.7,
+};

package/src/core/biomes/docs.js

@@ -0,0 +1,35 @@
+export const docsBiome = {
+  key: "docs",
+  name: "Garden Path",
+
+  trees: [
+    { species: "lamp_sprout",    minCommits: 1,   maxCommits: 2 },
+    { species: "garden_sapling", minCommits: 3,   maxCommits: 8 },
+    { species: "lantern_oak",    minCommits: 9,   maxCommits: 18 },
+    { species: "path_willow",    minCommits: 19,  maxCommits: 30 },
+    { species: "library_tree",   minCommits: 31,  maxCommits: 45 },
+    { species: "archive_oak",    minCommits: 46,  maxCommits: 65 },
+    { species: "ancient_yew",    minCommits: 66,  maxCommits: 100 },
+    { species: "crystal_tree",   minCommits: 101, maxCommits: Infinity },
+  ],
+
+  groundElements: ["lantern", "signpost", "stepping_stone", "bookmark_flower"],
+  animals: ["firefly", "robin", "hedgehog", "fox", "owl"],
+
+  palette: {
+    leaf: "#2a4a28", leafDark: "#1a3a20", leafLight: "#3a5a38",
+    ground: "#2a4a28", groundDark: "#1a3a18", groundLight: "#3a5a38",
+    grass: "#2a4a28", grassLight: "#3a5a38",
+  },
+
+  sky: { top: "#0f1028", mid: "#1a2048", bottom: "#1a3838" },
+
+  ground: {
+    grass: ["#2a4a28", "#1a3a18", "#183018"],
+    dirt: ["#2a2018", "#1a1810", "#141008"],
+  },
+
+  particles: ["warm_fireflies"],
+  bushes: ["garden_shrub", "herb_patch", "ivy_cluster"],
+  undergrowthDensity: 0.45,
+};

package/src/core/biomes/frontend.js

@@ -0,0 +1,35 @@
+export const frontendBiome = {
+  key: "frontend",
+  name: "Meadow",
+
+  trees: [
+    { species: "sprout",        minCommits: 1,   maxCommits: 2 },
+    { species: "young_maple",   minCommits: 3,   maxCommits: 8 },
+    { species: "wide_oak",      minCommits: 9,   maxCommits: 18 },
+    { species: "cherry",        minCommits: 19,  maxCommits: 30 },
+    { species: "magnolia",      minCommits: 31,  maxCommits: 45 },
+    { species: "wisteria",      minCommits: 46,  maxCommits: 65 },
+    { species: "ancient_maple", minCommits: 66,  maxCommits: 100 },
+    { species: "crystal_tree",  minCommits: 101, maxCommits: Infinity },
+  ],
+
+  groundElements: ["wildflower", "daisy", "smooth_rock", "clover"],
+  animals: ["butterfly", "songbird", "rabbit", "fox", "deer"],
+
+  palette: {
+    leaf: "#4a9a50", leafDark: "#2a7a30", leafLight: "#78c868",
+    ground: "#5a9a40", groundDark: "#3a7a28", groundLight: "#7aba58",
+    grass: "#5aaa38", grassLight: "#8ad068",
+  },
+
+  sky: { top: "#6699cc", mid: "#88bbdd", bottom: "#c8dde8" },
+
+  ground: {
+    grass: ["#5aaa38", "#4a9a28", "#3a8a20"],
+    dirt: ["#6a5530", "#5a4520", "#4a3510"],
+  },
+
+  particles: ["petals", "butterflies"],
+  bushes: ["meadow_shrub", "flower_bush", "clover_patch"],
+  undergrowthDensity: 0.6,
+};

package/src/core/biomes/general.js

@@ -0,0 +1,34 @@
+export const generalBiome = {
+  key: "general",
+  name: "Temperate Forest",
+
+  trees: [
+    { species: "sapling",      minCommits: 1,   maxCommits: 2 },
+    { species: "birch",        minCommits: 3,   maxCommits: 8 },
+    { species: "oak",          minCommits: 9,   maxCommits: 18 },
+    { species: "cherry",       minCommits: 19,  maxCommits: 30 },
+    { species: "pine",         minCommits: 31,  maxCommits: 45 },
+    { species: "willow",       minCommits: 46,  maxCommits: 65 },
+    { species: "ancient_oak",  minCommits: 66,  maxCommits: 100 },
+    { species: "crystal_tree", minCommits: 101, maxCommits: Infinity },
+  ],
+
+  groundElements: ["flower", "mushroom", "rock", "tall_grass"],
+
+  animals: ["butterfly", "rabbit", "fox", "deer", "owl"],
+
+  palette: {},  // empty = no overrides, uses BASE_PALETTE as-is
+
+  sky: { top: null, mid: null, bottom: null },  // null = use time-of-day defaults
+
+  ground: {
+    grass: ["#69a65d", "#8bcb73"],
+    dirt: ["#447055", "#345344"],
+  },
+
+  particles: ["leaves"],
+
+  bushes: ["tall_grass_bush", "fern_small", "shrub"],
+
+  undergrowthDensity: 0.4,
+};

package/src/core/biomes/index.js

@@ -0,0 +1,54 @@
+import { generalBiome } from "./general.js";
+import { frontendBiome } from "./frontend.js";
+import { backendBiome } from "./backend.js";
+import { aimlBiome } from "./aiml.js";
+import { infraBiome } from "./infra.js";
+import { docsBiome } from "./docs.js";
+
+const BIOME_REGISTRY = {
+  general: generalBiome,
+  frontend: frontendBiome,
+  backend: backendBiome,
+  aiml: aimlBiome,
+  infra: infraBiome,
+  docs: docsBiome,
+};
+
+export const BIOME_KEYS = ["general", "frontend", "backend", "aiml", "infra", "docs"];
+
+export function getBiomeConfig(key) {
+  return BIOME_REGISTRY[key] ?? BIOME_REGISTRY.general;
+}
+
+export function getSpeciesForCommit(totalCommits, biomeKey) {
+  const config = getBiomeConfig(biomeKey);
+  for (const tier of config.trees) {
+    if (totalCommits >= tier.minCommits && totalCommits <= tier.maxCommits) {
+      return tier.species;
+    }
+  }
+  return config.trees[config.trees.length - 1].species;
+}
+
+export function getGroundElementType(totalFileSaves, biomeKey) {
+  const config = getBiomeConfig(biomeKey);
+  const elements = config.groundElements;
+  const tier = Math.max(0, Math.floor(totalFileSaves / 100) - 1);
+  return elements[tier % elements.length];
+}
+
+export function getAnimalType(totalMinutesCoded, biomeKey) {
+  const config = getBiomeConfig(biomeKey);
+  const animals = config.animals;
+  const thresholds = [480, 240, 120, 60, 30];
+  for (let i = 0; i < thresholds.length; i++) {
+    if (totalMinutesCoded >= thresholds[i] && i < animals.length) {
+      return animals[animals.length - 1 - i];
+    }
+  }
+  return animals[0];
+}
+
+export function registerBiome(config) {
+  BIOME_REGISTRY[config.key] = config;
+}

package/src/core/biomes/infra.js

@@ -0,0 +1,35 @@
+export const infraBiome = {
+  key: "infra",
+  name: "Tundra",
+
+  trees: [
+    { species: "frozen_sprout",  minCommits: 1,   maxCommits: 2 },
+    { species: "bare_sapling",   minCommits: 3,   maxCommits: 8 },
+    { species: "hardy_pine",     minCommits: 9,   maxCommits: 18 },
+    { species: "frost_birch",    minCommits: 19,  maxCommits: 30 },
+    { species: "iron_pine",      minCommits: 31,  maxCommits: 45 },
+    { species: "stone_oak",      minCommits: 46,  maxCommits: 65 },
+    { species: "ancient_cedar",  minCommits: 66,  maxCommits: 100 },
+    { species: "crystal_tree",   minCommits: 101, maxCommits: Infinity },
+  ],
+
+  groundElements: ["lichen", "frozen_rock", "dead_branch", "ice_shard"],
+  animals: ["snowbird", "arctic_hare", "hawk", "mountain_goat", "snowy_owl"],
+
+  palette: {
+    leaf: "#3a5a48", leafDark: "#2a4a38", leafLight: "#4a6a58",
+    ground: "#d4dce4", groundDark: "#b8c8d4", groundLight: "#e0e8f0",
+    grass: "#d8e0e8", grassLight: "#e8f0f8",
+  },
+
+  sky: { top: "#5a6878", mid: "#8a9aaa", bottom: "#b0c0cc" },
+
+  ground: {
+    grass: ["#d8e0e8", "#c8d4de", "#b8c8d4"],
+    dirt: ["#6a6058", "#5a504a", "#4a4038"],
+  },
+
+  particles: ["snowflakes", "wind_gusts"],
+  bushes: ["dried_shrub", "snow_mound", "lichen_rock"],
+  undergrowthDensity: 0.25,
+};

package/src/core/environment.js

@@ -1,3 +1,5 @@
+import { getBiomeConfig } from "./biomes/index.js";
+
 const MINUTES_PER_DAY = 24 * 60;
 const TRANSITION_MINUTES = 30;
 
@@ -264,7 +266,17 @@ export function getSeasonPalette(season) {
   };
 }
 
-export function getEnvironmentSnapshot(date = new Date(), streak = 0) {
+export function getBiomePalette(season, biomeKey) {
+  const seasonPalette = getSeasonPalette(season);
+  if (!biomeKey || biomeKey === "general") {
+    return seasonPalette;
+  }
+  const biomeConfig = getBiomeConfig(biomeKey);
+  // Biome overrides go on top of season palette
+  return { ...seasonPalette, ...biomeConfig.palette };
+}
+
+export function getEnvironmentSnapshot(date = new Date(), streak = 0, biomeKey = null) {
   const season = getSeason(date);
   const sky = getSkyPhase(date);
   const weather = getWeather(streak, date);
@@ -275,7 +287,7 @@ export function getEnvironmentSnapshot(date = new Date(), streak = 0) {
     },
     sky,
     weather,
-    palette: getSeasonPalette(season),
+    palette: getBiomePalette(season, biomeKey),
   };
 }
 

package/src/core/progression.js

@@ -1,11 +1,14 @@
 import {
-  getAnimalTypeForMinutes,
   getAnimalSprite,
   getGroundElementSprite,
-  getGroundElementType,
-  getTreeSpeciesForCommit,
   getTreeSprite,
 } from "./sprites.js";
+import {
+  getBiomeConfig,
+  getSpeciesForCommit,
+  getGroundElementType,
+  getAnimalType,
+} from "./biomes/index.js";
 
 function hashString(value) {
   let hash = 0;
@@ -85,12 +88,19 @@ const ROW_SCALE = { back: 0.6, mid: 0.85, front: 1.0 };
 
 export function applyCommit(state, { commitHash = "", now = new Date() } = {}) {
   const nextTotal = state.total_commits + 1;
-  let species = getTreeSpeciesForCommit(nextTotal);
+  const biome = state.biome || "general";
+  let species = getSpeciesForCommit(nextTotal, biome);
   // Only one crystal tree allowed
   if (species === "crystal_tree" && state.trees.some((t) => t.species === "crystal_tree")) {
-    species = "ancient_oak";
+    const config = getBiomeConfig(biome);
+    species = config.trees[config.trees.length - 2].species;
+  }
+  let sprite;
+  try {
+    sprite = getTreeSprite(species);
+  } catch {
+    sprite = getTreeSprite("sapling");  // fallback for species without sprites yet
   }
-  const sprite = getTreeSprite(species);
   const row = chooseRow(state.trees);
   state.total_commits = nextTotal;
   state.current_streak = updateCommitStreak(state.current_streak, state.last_active_date, now);
@@ -113,8 +123,14 @@ export function applyCommit(state, { commitHash = "", now = new Date() } = {}) {
 export function applyFileSave(state, { now = new Date() } = {}) {
   state.total_file_saves += 1;
   if (state.total_file_saves % 100 === 0) {
-    const type = getGroundElementType(state.total_file_saves);
-    const sprite = getGroundElementSprite(type);
+    const biome = state.biome || "general";
+    const type = getGroundElementType(state.total_file_saves, biome);
+    let sprite;
+    try {
+      sprite = getGroundElementSprite(type);
+    } catch {
+      sprite = getGroundElementSprite("flower");
+    }
     state.ground_elements.push({
       type,
       x_position: placeSprite(
@@ -131,11 +147,17 @@ export function applyActiveMinutes(state, { minutes = 1, now = new Date() } = {}
   const before = state.total_minutes_coded;
   const after = before + minutes;
   state.total_minutes_coded = after;
+  const biome = state.biome || "general";
 
   let checkpoint = Math.floor(before / 30) * 30 + 30;
   while (checkpoint <= after) {
-    const type = getAnimalTypeForMinutes(checkpoint);
-    const sprite = getAnimalSprite(type);
+    const type = getAnimalType(checkpoint, biome);
+    let sprite;
+    try {
+      sprite = getAnimalSprite(type);
+    } catch {
+      sprite = getAnimalSprite("butterfly");
+    }
     state.animals.push({
       type,
       x_position: placeSprite(state.animals, sprite.width, `${type}:${checkpoint}`),