honeytree 1.0.9 → 1.1.1

package/package.json

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

package/src/commands/watch.js

@@ -1,7 +1,7 @@
 import React, { useEffect, useMemo, useState } from "react";
 import { Box, Text, render, useApp, useInput, useStdout } from "ink";
 
-import { applyActiveMinutes, applyActivityPulse, applyCommit, applyFileSave } from "../core/progression.js";
+import { applyActiveMinutes, applyCommit, applyFileSave } from "../core/progression.js";
 import { ensureState, readState, updateState } from "../core/state.js";
 import { renderTerminalFrame } from "../renderers/terminal.js";
 import { createActivityTracker } from "../tracker/activity.js";
@@ -70,10 +70,7 @@ function ForestWatchApp() {
       cwd: process.cwd(),
       onSave() {
         activity.markActive();
-        const nextState = updateState((draft) => {
-          applyActivityPulse(draft);
-          return applyFileSave(draft);
-        });
+        const nextState = updateState((draft) => applyFileSave(draft));
         setState(nextState);
       },
     });

package/src/core/animation.js

@@ -105,31 +105,42 @@ export function getWeatherParticles(width, height, tick = 0, weather = "clear",
   }));
 }
 
-export function getLlamaAnimation(width, tick = 0, lastSaveTick = -Infinity) {
-  const speed = 0.06;
-  const cycle = width * 2;
-  const raw = (tick * speed) % cycle;
-  const x = raw < width ? raw : cycle - raw;
-  const direction = raw < width ? "right" : "left";
-
-  const ticksSinceSave = tick - lastSaveTick;
-  let pose = "walking";
-  if (ticksSinceSave < 8) {
-    pose = "happy";
-  } else if (ticksSinceSave > 300) {
-    pose = "sitting";
-  }
-
-  return { x: Math.round(x), y: 11, direction, pose };
-}
-
-export function getDynamicScene(state, width, tick, environment, lastSaveTick = -Infinity) {
+export function getDynamicScene(state, width, tick, environment) {
   return {
     clouds: getClouds(width, tick, environment.sky.name),
     stars: environment.sky.name === "night" ? getStars(width, tick) : [],
     animals: getAnimatedAnimals(state, width, tick),
     particles: getWeatherParticles(width, 12, tick, environment.weather.name, environment.season.name),
-    llama: getLlamaAnimation(width, tick, lastSaveTick),
+  };
+}
+
+export function getCrystalPalette(tick) {
+  const CRYSTAL_COLORS = ["#00e5ff", "#e040fb", "#69f0ae"];
+  const cycle = (tick * 0.02) % 3;
+  const index = Math.floor(cycle);
+  const next = (index + 1) % 3;
+  const t = cycle - index;
+  function lerpChannel(a, b, amount) {
+    return Math.round(a + (b - a) * amount);
+  }
+  function parseHex(hex) {
+    const n = hex.slice(1);
+    return [parseInt(n.slice(0, 2), 16), parseInt(n.slice(2, 4), 16), parseInt(n.slice(4, 6), 16)];
+  }
+  function toHex(r, g, b) {
+    return "#" + [r, g, b].map((v) => Math.min(255, Math.max(0, v)).toString(16).padStart(2, "0")).join("");
+  }
+  const from = parseHex(CRYSTAL_COLORS[index]);
+  const to = parseHex(CRYSTAL_COLORS[next]);
+  const mixed = toHex(
+    lerpChannel(from[0], to[0], t),
+    lerpChannel(from[1], to[1], t),
+    lerpChannel(from[2], to[2], t),
+  );
+  return {
+    crystal1: mixed,
+    crystal2: CRYSTAL_COLORS[next],
+    crystal3: CRYSTAL_COLORS[(next + 1) % 3],
   };
 }
 

package/src/core/environment.js

@@ -85,10 +85,9 @@ const BASE_PALETTE = {
   deerLight: "#cba37b",
   owl: "#5f5b6b",
   owlLight: "#d8d7dd",
-  llama: "#e8ddd0",
-  llamaLight: "#f5f0ea",
-  llamaDark: "#c4b5a3",
-  llamaNose: "#f5a0b0",
+  crystal1: "#00e5ff",
+  crystal2: "#e040fb",
+  crystal3: "#69f0ae",
 };
 
 const SEASON_OVERRIDES = {

package/src/core/progression.js

@@ -1,5 +1,3 @@
-import { addMinutes } from "date-fns";
-
 import {
   getAnimalTypeForMinutes,
   getAnimalSprite,
@@ -72,10 +70,28 @@ export function updateCommitStreak(currentStreak, lastActiveDate, now = new Date
   return 1;
 }
 
+function chooseRow(trees) {
+  const counts = { back: 0, mid: 0, front: 0 };
+  for (const tree of trees) {
+    const row = tree.row || "front";
+    counts[row] = (counts[row] || 0) + 1;
+  }
+  if (counts.back <= counts.mid && counts.back <= counts.front) return "back";
+  if (counts.mid <= counts.front) return "mid";
+  return "front";
+}
+
+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;
-  const species = getTreeSpeciesForCommit(nextTotal);
+  let species = getTreeSpeciesForCommit(nextTotal);
+  // Only one crystal tree allowed
+  if (species === "crystal_tree" && state.trees.some((t) => t.species === "crystal_tree")) {
+    species = "ancient_oak";
+  }
   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);
   state.last_active_date = dayString(now);
@@ -83,14 +99,20 @@ export function applyCommit(state, { commitHash = "", now = new Date() } = {}) {
   state.trees.push({
     species,
     planted_at: now.toISOString(),
-    x_position: placeSprite(state.trees, sprite.width, `${species}:${nextTotal}`),
+    x_position: placeSprite(
+      state.trees.filter((t) => t.row === row),
+      sprite.width,
+      `${species}:${nextTotal}`,
+    ),
+    row,
+    scale: ROW_SCALE[row],
   });
   return state;
 }
 
 export function applyFileSave(state, { now = new Date() } = {}) {
   state.total_file_saves += 1;
-  if (state.total_file_saves % 50 === 0) {
+  if (state.total_file_saves % 100 === 0) {
     const type = getGroundElementType(state.total_file_saves);
     const sprite = getGroundElementSprite(type);
     state.ground_elements.push({
@@ -125,7 +147,3 @@ export function applyActiveMinutes(state, { minutes = 1, now = new Date() } = {}
   return state;
 }
 
-export function applyActivityPulse(state, { now = new Date() } = {}) {
-  const updated = addMinutes(now, 0);
-  return state;
-}

package/src/core/sprites.js

@@ -8,12 +8,11 @@ export const TREE_SPECIES = [
   "pine",
   "willow",
   "ancient_oak",
+  "crystal_tree",
 ];
 
 export const ANIMAL_TYPES = ["butterfly", "rabbit", "fox", "deer", "owl"];
 
-export const LLAMA_POSES = ["walking", "sitting", "happy"];
-
 export const GROUND_ELEMENT_TYPES = ["flower", "mushroom", "rock", "tall_grass"];
 
 function parseSprite(template, legend) {
@@ -57,17 +56,18 @@ export function materializeSprite(sprite, palette, char = BLOCK) {
 }
 
 export function getTreeSpeciesForCommit(totalCommits) {
-  if (totalCommits <= 5) return "sapling";
-  if (totalCommits <= 15) return "birch";
-  if (totalCommits <= 30) return "oak";
-  if (totalCommits <= 50) return "cherry";
-  if (totalCommits <= 75) return "pine";
-  if (totalCommits <= 100) return "willow";
-  return "ancient_oak";
+  if (totalCommits <= 2) return "sapling";
+  if (totalCommits <= 8) return "birch";
+  if (totalCommits <= 18) return "oak";
+  if (totalCommits <= 30) return "cherry";
+  if (totalCommits <= 45) return "pine";
+  if (totalCommits <= 65) return "willow";
+  if (totalCommits <= 100) return "ancient_oak";
+  return "crystal_tree";
 }
 
 export function getGroundElementType(totalFileSaves) {
-  const tier = Math.max(0, Math.floor(totalFileSaves / 50) - 1);
+  const tier = Math.max(0, Math.floor(totalFileSaves / 100) - 1);
   return GROUND_ELEMENT_TYPES[tier % GROUND_ELEMENT_TYPES.length];
 }
 
@@ -82,9 +82,11 @@ export function getAnimalTypeForMinutes(totalMinutesCoded) {
 const TREE_SPRITES = {
   sapling: parseSprite(
     `
-  l
- lL
-  t
+    l
+   lLl
+    l
+    t
+    t
 `,
     {
       l: "leaf",
@@ -94,11 +96,14 @@ const TREE_SPRITES = {
   ),
   birch: parseSprite(
     `
-   ll
-  lLL
- llLLl
-   bb
-   bB
+     ll
+    lLLl
+   lLLLLl
+    lLLl
+     bb
+     bB
+     bb
+     bB
 `,
     {
       l: "leaf",
@@ -109,12 +114,16 @@ const TREE_SPRITES = {
   ),
   oak: parseSprite(
     `
-    dd
-  dllll
- dllLLlld
-  llllll
-    tt
-   tTT
+      ddd
+    ddlllld
+   dlllLLllld
+   dllLLLLlld
+    dlllllld
+     llllll
+       tt
+      tTTt
+      tTTt
+       tt
 `,
     {
       d: "leafDark",
@@ -126,12 +135,16 @@ const TREE_SPRITES = {
   ),
   cherry: parseSprite(
     `
-    pp
-  pPPPP
- pPPpPPP
-  PPPPP
-    tt
-   tTT
+      ppp
+    ppPPPPp
+   pPPPpPPPp
+   pPPPPPPPp
+    pPPPPPp
+     PPPPp
+       tt
+      tTTt
+      tTTt
+       tt
 `,
     {
       p: "petal",
@@ -142,13 +155,16 @@ const TREE_SPRITES = {
   ),
   pine: parseSprite(
     `
-     p
-    pPp
-   pPPPp
-  pPPPPPp
-   PPPPP
-    tT
-    tT
+       p
+      pPp
+     pPPPp
+      PPP
+     pPPPp
+    pPPPPPp
+     PPPPP
+      tTt
+      tTt
+       t
 `,
     {
       p: "pineDark",
@@ -159,13 +175,18 @@ const TREE_SPRITES = {
   ),
   willow: parseSprite(
     `
-    llll
-  llLLLLll
- llLllllLll
- ll      ll
-  ll    ll
-    tTT
-    tTT
+      llll
+    llLLLLll
+   llLLllLLll
+   lLl    lLl
+   ll      ll
+   ll      ll
+    l      l
+      tTTt
+      tTTt
+       tT
+       tT
+       tt
 `,
     {
       l: "leaf",
@@ -176,14 +197,20 @@ const TREE_SPRITES = {
   ),
   ancient_oak: parseSprite(
     `
-      dd
-   ddllllld
-  dllLLLllld
- ddllLLLllld
-   llllllll
-     mmm
-    tTTT
-   ttTTtt
+        ddd
+     dddllllddd
+    ddllLLLLlldd
+   dddllLLLLllddd
+   ddlllLLLllldd
+    ddlllllllldd
+      mllllllm
+       mmmm
+      tTTTTt
+      tTTTTt
+     ttTTTTtt
+     tt    tt
+      t    t
+      t    t
 `,
     {
       d: "leafDark",
@@ -194,13 +221,37 @@ const TREE_SPRITES = {
       T: "trunk",
     },
   ),
+  crystal_tree: parseSprite(
+    `
+       cc
+     ccCCCc
+    cCCcCCCc
+    cCCCCCCc
+     cCCCCc
+      CCCc
+       tt
+      tTTt
+      tTTt
+       tT
+       tt
+       tt
+`,
+    {
+      c: "crystal1",
+      C: "crystal2",
+      t: "trunkDark",
+      T: "trunk",
+    },
+  ),
 };
 
 const ANIMAL_SPRITES = {
   butterfly: parseSprite(
     `
-w w
- W
+w   w
+wW Ww
+ WWW
+  W
 `,
     {
       w: "wing",
@@ -209,9 +260,10 @@ w w
   ),
   rabbit: parseSprite(
     `
- ee
-rrre
- rr
+  ee
+ rrre
+rrrrr
+ rr r
 `,
     {
       r: "rabbit",
@@ -220,9 +272,11 @@ rrre
   ),
   fox: parseSprite(
     `
- ff
-ffff
-fllf
+  ff
+ ffff
+ffffff
+fl  lf
+ f  f
 `,
     {
       f: "fox",
@@ -231,20 +285,26 @@ fllf
   ),
   deer: parseSprite(
     `
+a  a
  aa
-dddd
-d dd
+dddddd
+dl  ld
+ d  d
+ d  d
 `,
     {
       a: "deerLight",
       d: "deer",
+      l: "deerLight",
     },
   ),
   owl: parseSprite(
     `
- oo
-OooO
- tt
+  oo
+ OooO
+OooooO
+ oooo
+  tt
 `,
     {
       o: "owl",
@@ -254,47 +314,6 @@ OooO
   ),
 };
 
-const LLAMA_SPRITES = {
-  walking: parseSprite(
-    `
-  ee
- lllN
-llll
-l  l
-`,
-    {
-      e: "llamaLight",
-      l: "llama",
-      N: "llamaNose",
-    },
-  ),
-  sitting: parseSprite(
-    `
-  ee
- lllN
- lll
-  ll
-`,
-    {
-      e: "llamaLight",
-      l: "llama",
-      N: "llamaNose",
-    },
-  ),
-  happy: parseSprite(
-    `
-  ee
- lllN
-llll
-l  l
-`,
-    {
-      e: "llamaLight",
-      l: "llama",
-      N: "llamaNose",
-    },
-  ),
-};
 
 const GROUND_SPRITES = {
   flower: parseSprite(
@@ -364,13 +383,6 @@ export function getGroundElementSprite(type) {
   return sprite;
 }
 
-export function getLlamaSprite(pose = "walking") {
-  const sprite = LLAMA_SPRITES[pose];
-  if (!sprite) {
-    throw new Error(`Unknown llama pose: ${pose}`);
-  }
-  return sprite;
-}
 
 export function getRandomGroundElement() {
   return GROUND_ELEMENT_TYPES[Math.floor(Math.random() * GROUND_ELEMENT_TYPES.length)];

package/src/core/state.js

@@ -40,17 +40,30 @@ export function createEmptyState(now = new Date()) {
     current_streak: 0,
     last_active_date: todayString(now),
     last_commit_hash: "",
+    global_trees: 0,
     trees: [],
     animals: [],
     ground_elements: [],
   };
 }
 
-function normalizeTree(tree) {
+function assignRowByIndex(index, total) {
+  if (total <= 0) return "front";
+  const third = total / 3;
+  if (index < third) return "back";
+  if (index < third * 2) return "mid";
+  return "front";
+}
+
+function normalizeTree(tree, index, total) {
+  const row = tree?.row || assignRowByIndex(index, total);
+  const scaleMap = { back: 0.6, mid: 0.85, front: 1.0 };
   return {
     species: tree?.species ?? tree?.type ?? "sapling",
     planted_at: tree?.planted_at ?? tree?.plantedAt ?? new Date().toISOString(),
     x_position: Number.isFinite(tree?.x_position) ? tree.x_position : tree?.x ?? 12,
+    row,
+    scale: scaleMap[row] ?? 1.0,
   };
 }
 
@@ -88,7 +101,8 @@ function rescalePositions(items) {
 
 export function normalizeState(input = {}) {
   const base = createEmptyState();
-  const trees = Array.isArray(input.trees) ? input.trees.map(normalizeTree) : [];
+  const rawTrees = Array.isArray(input.trees) ? input.trees : [];
+  const trees = rawTrees.map((tree, index) => normalizeTree(tree, index, rawTrees.length));
   const animals = Array.isArray(input.animals) ? input.animals.map(normalizeAnimal) : [];
   const ground_elements = Array.isArray(input.ground_elements)
     ? input.ground_elements.map(normalizeGroundElement)
@@ -107,6 +121,7 @@ export function normalizeState(input = {}) {
         ? input.last_active_date
         : input.lastActiveDate ?? base.last_active_date,
     last_commit_hash: typeof input.last_commit_hash === "string" ? input.last_commit_hash : "",
+    global_trees: Number.isFinite(input.global_trees) ? input.global_trees : 0,
     trees: rescalePositions(trees),
     animals: rescalePositions(animals),
     ground_elements: rescalePositions(ground_elements),
@@ -118,7 +133,8 @@ export function migrateOldForest(oldForest = {}) {
   migrated.total_commits = oldForest.totalPrompts ?? oldForest.trees?.length ?? 0;
   migrated.current_streak = oldForest.streak ?? 0;
   migrated.last_active_date = oldForest.lastActiveDate ?? todayString();
-  migrated.trees = Array.isArray(oldForest.trees) ? oldForest.trees.map(normalizeTree) : [];
+  const rawTrees = Array.isArray(oldForest.trees) ? oldForest.trees : [];
+  migrated.trees = rawTrees.map((tree, index) => normalizeTree(tree, index, rawTrees.length));
   return migrated;
 }
 

package/src/renderers/terminal.js

@@ -1,12 +1,11 @@
 import chalk from "chalk";
 
-import { getDynamicScene } from "../core/animation.js";
-import { getEnvironmentSnapshot } from "../core/environment.js";
+import { getDynamicScene, getCrystalPalette } from "../core/animation.js";
+import { getEnvironmentSnapshot, lerpColor } from "../core/environment.js";
 import { VIRTUAL_WIDTH } from "../core/progression.js";
 import {
   getAnimalSprite,
   getGroundElementSprite,
-  getLlamaSprite,
   getTreeSprite,
   materializeSprite,
 } from "../core/sprites.js";
@@ -21,14 +20,20 @@ export const SCENE_HEIGHT = ART_ROWS + STATS_ROWS;
 
 function createBuffer(width) {
   return Array.from({ length: ART_ROWS }, () =>
-    Array.from({ length: width }, () => ({ char: " ", color: null })),
+    Array.from({ length: width }, () => ({ char: " ", color: null, bg: null })),
   );
 }
 
 function paint(buffer, x, y, char, color) {
   if (y < 0 || y >= buffer.length) return;
   if (x < 0 || x >= buffer[0].length) return;
-  buffer[y][x] = { char, color };
+  buffer[y][x] = { char, color, bg: buffer[y][x].bg };
+}
+
+function paintBg(buffer, x, y, bg) {
+  if (y < 0 || y >= buffer.length) return;
+  if (x < 0 || x >= buffer[0].length) return;
+  buffer[y][x].bg = bg;
 }
 
 function compositeSprite(buffer, sprite, centerX, baseY, palette) {
@@ -45,11 +50,42 @@ function compositeSprite(buffer, sprite, centerX, baseY, palette) {
   }
 }
 
-function colorize(text, color, enabled) {
-  if (!enabled || !color) {
-    return text;
+function colorize(text, color, bg, enabled) {
+  if (!enabled) return text;
+  if (!color && !bg) return text;
+  let fn = chalk;
+  if (bg) fn = fn.bgHex(bg);
+  if (color) fn = fn.hex(color);
+  return fn(text);
+}
+
+function drawSkyBackground(buffer, width, environment) {
+  const sky = environment.sky;
+  // Sky rows: vertical gradient from top → mid → bottom
+  for (let y = 0; y < SKY_ROWS; y++) {
+    const t = y / Math.max(1, SKY_ROWS - 1);
+    let color;
+    if (t < 0.5) {
+      color = lerpColor(sky.top, sky.mid, t * 2);
+    } else {
+      color = lerpColor(sky.mid, sky.bottom, (t - 0.5) * 2);
+    }
+    for (let x = 0; x < width; x++) {
+      paintBg(buffer, x, y, color);
+    }
+  }
+  // Forest rows: blend from sky.bottom toward ground
+  for (let y = SKY_ROWS; y < SKY_ROWS + FOREST_ROWS; y++) {
+    const t = (y - SKY_ROWS) / Math.max(1, FOREST_ROWS - 1);
+    const color = lerpColor(sky.bottom, environment.palette.groundDark, t * 0.7);
+    for (let x = 0; x < width; x++) {
+      paintBg(buffer, x, y, color);
+    }
+  }
+  // Ground row: solid ground color
+  for (let x = 0; x < width; x++) {
+    paintBg(buffer, x, ART_ROWS - 1, environment.palette.groundDark);
   }
-  return chalk.hex(color)(text);
 }
 
 function drawSky(buffer, width, environment, tick) {
@@ -127,10 +163,50 @@ function scaleX(virtualX, width) {
   return Math.round((virtualX / VIRTUAL_WIDTH) * width);
 }
 
+function spaceTrees(trees, width, minGap) {
+  const sorted = [...trees].sort((a, b) => a.x_position - b.x_position);
+  const result = [];
+  let lastScreenX = -Infinity;
+  for (const tree of sorted) {
+    const screenX = Math.round((tree.x_position / VIRTUAL_WIDTH) * width);
+    if (screenX - lastScreenX >= minGap) {
+      result.push(tree);
+      lastScreenX = screenX;
+    }
+  }
+  return result;
+}
+
 function drawForest(buffer, width, state, environment, tick) {
   const treeBaseY = SKY_ROWS + FOREST_ROWS - 1;
-  for (const tree of state.trees) {
-    compositeSprite(buffer, getTreeSprite(tree.species), scaleX(tree.x_position, width), treeBaseY, environment.palette);
+  const isSunsetSilhouette = environment.sky.name === "sunset";
+  const silhouettePalette = {};
+  if (isSunsetSilhouette) {
+    for (const key of Object.keys(environment.palette)) {
+      silhouettePalette[key] = "#1a1a2e";
+    }
+  }
+
+  const crystalPalette = getCrystalPalette(tick);
+
+  // Separate trees by row, then filter for spacing
+  const minGap = { back: 6, mid: 10, front: 14 };
+  const rows = ["back", "mid", "front"];
+  for (const targetRow of rows) {
+    const rowTrees = state.trees.filter((t) => (t.row || "front") === targetRow);
+    const spaced = spaceTrees(rowTrees, width, minGap[targetRow]);
+    const rowY = targetRow === "back" ? treeBaseY - 2 : targetRow === "mid" ? treeBaseY - 1 : treeBaseY;
+
+    for (const tree of spaced) {
+      let palette = environment.palette;
+      if (tree.species === "crystal_tree") {
+        palette = { ...environment.palette, ...crystalPalette };
+      }
+      if (isSunsetSilhouette) {
+        palette = silhouettePalette;
+      }
+      compositeSprite(buffer, getTreeSprite(tree.species), scaleX(tree.x_position, width), rowY, palette);
+    }
   }
 
   for (const element of state.ground_elements) {
@@ -138,7 +214,9 @@ function drawForest(buffer, width, state, environment, tick) {
   }
 
   const scene = getDynamicScene(state, width, tick, environment);
-  for (const animal of scene.animals) {
+  const maxAnimals = Math.max(2, Math.min(4, Math.floor(width / 25)));
+  const visibleAnimals = scene.animals.slice(0, maxAnimals);
+  for (const animal of visibleAnimals) {
     if (animal.type === "owl" && environment.sky.name !== "night") {
       continue;
     }
@@ -150,18 +228,6 @@ function drawForest(buffer, width, state, environment, tick) {
       environment.palette,
     );
   }
-
-  // Llama companion
-  const llama = scene.llama;
-  if (llama) {
-    compositeSprite(
-      buffer,
-      getLlamaSprite(llama.pose),
-      llama.x,
-      Math.min(ART_ROWS - 2, llama.y),
-      environment.palette,
-    );
-  }
 }
 
 function drawGround(buffer, width, environment) {
@@ -175,12 +241,12 @@ function buildStatsLine(state, environment, width, color) {
   const animals = `${state.animals.length} animal${state.animals.length === 1 ? "" : "s"}`;
   const streak = `${state.current_streak} day streak`;
   const weather = `${environment.season.icon} ${environment.season.label} ${environment.weather.label}`;
-  const separator = colorize(" • ", "#6b7280", color);
+  const separator = colorize(" • ", "#6b7280", null, color);
   const line = [
-    colorize("🌲 " + trees, "#7bd389", color),
-    colorize("🐇 " + animals, "#f4d35e", color),
-    colorize("🔥 " + streak, "#ee964b", color),
-    colorize(weather, "#d4d4d8", color),
+    colorize("🌲 " + trees, "#7bd389", null, color),
+    colorize("🐇 " + animals, "#f4d35e", null, color),
+    colorize("🔥 " + streak, "#ee964b", null, color),
+    colorize(weather, "#d4d4d8", null, color),
   ].join(separator);
 
   if (line.length >= width) {
@@ -195,6 +261,7 @@ export function buildTerminalScene(state, termWidth = 80, tick = 0, options = {}
   const environment = getEnvironmentSnapshot(date, state.current_streak ?? 0);
   const buffer = createBuffer(width);
 
+  drawSkyBackground(buffer, width, environment);
   drawSky(buffer, width, environment, tick);
   drawWeather(buffer, width, environment, tick);
   drawSeasonParticles(buffer, width, environment, tick);
@@ -221,7 +288,7 @@ export function renderTerminalFrame(state, termWidth = 80, tick = 0, options = {
   const scene = buildTerminalScene(state, termWidth, tick, options);
   const lines = scene.buffer.map((row) =>
     row
-      .map((cell) => colorize(cell.char, cell.color, options.color !== false))
+      .map((cell) => colorize(cell.char, cell.color, cell.bg, options.color !== false))
       .join(""),
   );
   lines.push(scene.statsLine);