honeytree 1.0.1 → 1.0.3

package/README.md

@@ -1,44 +1,117 @@
 # Honeytree
 
+[![npm version](https://img.shields.io/npm/v/honeytree.svg)](https://www.npmjs.com/package/honeytree)
+[![license](https://img.shields.io/npm/l/honeytree.svg)](https://github.com/Varun2009178/honeytree/blob/main/LICENSE)
+
 Grow a pixel-art forest in your terminal every time you use Claude Code.
 
 Each prompt plants a new tree. Each tree grows over time. Your forest evolves from a quiet clearing into an ancient woodland — and it never resets.
 
-## Install
+---
+
+## Quick Start
 
 ```bash
 npm install -g honeytree
+honeytree init
+honeytree
 ```
 
-## Setup
+That's it. Three commands:
+
+1. **Install** the CLI globally
+2. **Init** creates your forest file and registers a Claude Code hook
+3. **Run the viewer** in a separate terminal to watch your forest grow
+
+After setup, trees are planted automatically after every Claude Code response. No manual steps needed.
+
+---
+
+## How It Works
+
+When you run `honeytree init`, it does two things:
+
+- Creates `~/.honeydew/forest.json` to store your forest state
+- Adds a `Stop` hook to `~/.claude/settings.json` that runs after every Claude Code response
+
+From then on, every time Claude Code responds to a prompt, a new tree is planted in your forest automatically. Open the viewer in a second terminal to watch them grow in real time.
+
+---
+
+## Streaks
+
+Honeytree tracks your coding streak — consecutive days where you use Claude Code.
+
+- **Active streak**: The viewer and badge show your current streak count (e.g. `7-day streak`)
+- **Broken streak**: Miss a day and your forest starts **wilting** — trees desaturate toward brown, and fog rolls in across the scene
+- **Recovery**: Your next prompt resets the streak to 1 and clears the wilting immediately
+
+The longer you go without coding, the worse it gets:
+
+| Days idle | Effect |
+|----------:|--------|
+| 1 | Light desaturation, sparse fog |
+| 2 | Noticeable browning, moderate fog |
+| 3 | Heavy browning, dense fog |
+| 4+ | Near-dead forest, thick fog |
+
+Plant a tree to bring it all back to life.
+
+---
+
+## Badge
+
+Generate a badge for your GitHub README that shows your forest stats and links back to [Honeytree](https://github.com/Varun2009178/honeytree):
 
 ```bash
-honeytree init
+honeytree badge
+```
+
+This creates a `honeytree-badge.svg` file in your current directory and prints the markdown to embed it:
+
+```markdown
+[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)
 ```
 
-This creates `~/.honeydew/forest.json` and adds a `Stop` hook to your Claude Code settings so a tree is planted after every response.
+The badge displays your tree count and streak status. It links to the [Honeytree repo](https://github.com/Varun2009178/honeytree) so anyone who sees it can install it themselves.
 
-## Watch your forest
+| State | Badge color | Example |
+|-------|-------------|---------|
+| Active streak | Green | `42 trees · 7d streak` |
+| Wilting | Orange-red | `42 trees · wilting` |
+| No streak data | Grey | `42 trees` |
+
+Re-run `honeytree badge` any time to update the SVG with your latest stats. Commit it to your repo to keep it current.
+
+---
+
+## FOREST.md
+
+Generate a shareable markdown snapshot of your forest:
 
 ```bash
-honeytree
+honeytree md
 ```
 
-Open this in a separate terminal. It watches your forest file and animates new trees as they appear. Press `Ctrl+C` to exit.
+This creates a `FOREST.md` in your current directory with:
+
+- Your Honeytree badge (links to the [Honeytree repo](https://github.com/Varun2009178/honeytree))
+- Stats: tree count, streak, biome
+- A plain-text rendering of your forest (tree silhouettes, stars, ground)
+- Total prompts and forest age
 
-## How it works
+Commit `FOREST.md` to your repo root so your team can see the forest. When teammates see it, they can install Honeytree themselves — one install spreads to the whole team.
 
-1. **`honeytree init`** — Creates the forest state file and registers a Claude Code hook
-2. **`honeytree`** — Opens the viewer that renders your forest in real time
+Run `honeytree badge` first to generate the SVG, then `honeytree md` to generate the markdown that embeds it.
 
-After init, a tree is automatically planted after every Claude Code response via the hook. Each tree is a random species (oak, pine, birch, willow, or cherry) and growth stage. Existing young trees grow a little each time too.
+---
 
 ## Biomes
 
-Your forest evolves as it grows:
+Your forest evolves visually as it grows — the sky, ground, and atmosphere all change:
 
 | Trees | Biome | What changes |
-|-------|-------|-------------|
+|------:|-------|-------------|
 | 0–9 | Clearing | Sparse stars, light ground |
 | 10–24 | Grove | More stars, richer ground |
 | 25–49 | Woodland | Dense canopy, varied starlight |
@@ -47,20 +120,73 @@ Your forest evolves as it grows:
 
 Trees are never deleted. The forest only grows.
 
-## Tree types
+---
+
+## Tree Species
+
+Five species are randomly assigned when a tree is planted:
+
+| Species | Look |
+|---------|------|
+| Oak | Wide, rounded canopy |
+| Pine | Tall, triangular shape |
+| Birch | Light trunk, bright leaves |
+| Willow | Drooping canopy |
+| Cherry | Pink blossoms |
+
+Each species has 4 growth stages (seed, sapling, young, full). Existing trees grow a little with each new prompt.
+
+---
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `honeytree init` | Create forest and register Claude Code hook |
+| `honeytree` | Launch the live viewer |
+| `honeytree plant` | Plant a tree manually (normally runs via hook) |
+| `honeytree badge` | Generate `honeytree-badge.svg` in current directory |
+| `honeytree md` | Generate `FOREST.md` in current directory |
 
-- **Oak** — Wide, rounded canopy
-- **Pine** — Tall, triangular shape
-- **Birch** — Light trunk, bright leaves
-- **Willow** — Drooping canopy
-- **Cherry** — Pink blossoms
+---
 
-Each type has 4 growth stages: seed, sapling, young, and full.
+## Viewer
+
+The viewer adapts to your terminal width — expand your terminal and new trees will spread across the full width.
+
+Press `Ctrl+C` to exit. The viewer shows a summary of your forest when you close it.
+
+### Reading the Stats Bar
+
+Below your forest you'll see a stats bar like this:
+
+```
+ honeytree · 42 trees · 7-day streak · ████████░░░░ next: oak [woodland]
+```
+
+Here's what each part means:
+
+| Segment | What it tells you |
+|---------|-------------------|
+| `42 trees` | Total trees in your forest — one planted per prompt, never deleted |
+| `7-day streak` | Consecutive days you've used Claude Code. Resets to 1 if you skip a day |
+| `wilting (2d idle)` | Appears instead of streak when you've been inactive — your forest is dying |
+| `████████░░░░` | Progress bar toward the next milestone (10, 25, 50, 100, 250, 500, 1000 trees) |
+| `next: oak` | The species of the next tree that will be planted |
+| `[woodland]` | Your current biome — evolves as your tree count grows |
+
+---
 
 ## Requirements
 
 - Node.js 18+
-- Claude Code (for the automatic hook)
+- [Claude Code](https://claude.com/claude-code) (for the automatic hook)
+
+## Links
+
+- **npm**: [npmjs.com/package/honeytree](https://www.npmjs.com/package/honeytree)
+- **GitHub**: [github.com/Varun2009178/honeytree](https://github.com/Varun2009178/honeytree)
+- **Issues**: [github.com/Varun2009178/honeytree/issues](https://github.com/Varun2009178/honeytree/issues)
 
 ## License
 

package/bin/honeydew.js

@@ -8,11 +8,17 @@ if (command === "init") {
 } else if (command === "plant") {
   const { plant } = await import("../src/plant.js");
   await plant();
+} else if (command === "badge") {
+  const { badge } = await import("../src/badge.js");
+  await badge();
+} else if (command === "md") {
+  const { generateForestMd } = await import("../src/markdown.js");
+  await generateForestMd();
 } else if (!command) {
   const { viewer } = await import("../src/viewer.js");
   await viewer();
 } else {
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: honeytree [init|plant]");
+  console.error("Usage: honeytree [init|plant|badge|md]");
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeytree",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Grow a forest in your terminal every time you use Claude Code",
   "type": "module",
   "bin": {

package/src/badge.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { readForest } from "./state.js";
+
+const CHAR_WIDTH = 6.8;
+const PADDING = 10;
+const HEIGHT = 20;
+
+function sectionWidth(text) {
+  return Math.round(text.length * CHAR_WIDTH + PADDING * 2);
+}
+
+function buildMessage(forest) {
+  const count = forest.trees.length;
+  const streak = forest.streak || 0;
+  const treePart = `${count} tree${count === 1 ? "" : "s"}`;
+
+  if (!forest.lastActiveDate) return treePart;
+
+  const today = new Date().toISOString().slice(0, 10);
+  const a = new Date(forest.lastActiveDate + "T00:00:00");
+  const b = new Date(today + "T00:00:00");
+  const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+
+  if (idle > 0) return `${treePart} · wilting`;
+  if (streak > 0) return `${treePart} · ${streak}d streak`;
+  return treePart;
+}
+
+function badgeColor(forest) {
+  if (!forest.lastActiveDate) return "#555";
+  const today = new Date().toISOString().slice(0, 10);
+  const a = new Date(forest.lastActiveDate + "T00:00:00");
+  const b = new Date(today + "T00:00:00");
+  const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+  if (idle > 0) return "#c4653a";
+  return "#2ea043";
+}
+
+function generateSVG(label, message, color) {
+  const lw = sectionWidth(label);
+  const mw = sectionWidth(message);
+  const tw = lw + mw;
+  const lx = lw / 2;
+  const mx = lw + mw / 2;
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${tw}" height="${HEIGHT}" role="img" aria-label="${label}: ${message}">
+  <title>${label}: ${message}</title>
+  <linearGradient id="s" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="r"><rect width="${tw}" height="${HEIGHT}" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="${lw}" height="${HEIGHT}" fill="#555"/>
+    <rect x="${lw}" width="${mw}" height="${HEIGHT}" fill="${color}"/>
+    <rect width="${tw}" height="${HEIGHT}" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="11">
+    <text aria-hidden="true" x="${lx}" y="15" fill="#010101" fill-opacity=".3">${label}</text>
+    <text x="${lx}" y="14">${label}</text>
+    <text aria-hidden="true" x="${mx}" y="15" fill="#010101" fill-opacity=".3">${message}</text>
+    <text x="${mx}" y="14">${message}</text>
+  </g>
+</svg>`;
+}
+
+export async function badge() {
+  const forest = readForest();
+  if (!forest) {
+    console.error('No forest found. Run "honeytree init" first.');
+    process.exit(1);
+  }
+
+  const label = "honeytree";
+  const message = buildMessage(forest);
+  const color = badgeColor(forest);
+  const svg = generateSVG(label, message, color);
+
+  const outPath = path.resolve("honeytree-badge.svg");
+  fs.writeFileSync(outPath, svg);
+
+  console.log(`Badge written to ${outPath}`);
+  console.log("");
+  console.log("Add this to your README to show your Honeytree stats.");
+  console.log("The badge links to https://github.com/Varun2009178/honeytree");
+  console.log("");
+  console.log(
+    `[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)`,
+  );
+}

package/src/markdown.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { readForest } from "./state.js";
+import { renderPlainText, getWiltFactor } from "./renderer.js";
+
+function getBiomeLabel(count) {
+  if (count < 10) return "clearing";
+  if (count < 25) return "grove";
+  if (count < 50) return "woodland";
+  if (count < 100) return "old growth";
+  return "ancient forest";
+}
+
+function getDayCount(createdAt) {
+  const created = new Date(createdAt).getTime();
+  const diff = Date.now() - created;
+  return Math.max(1, Math.floor(diff / (24 * 60 * 60 * 1000)) + 1);
+}
+
+function buildMarkdown(forest) {
+  const count = forest.trees.length;
+  const streak = forest.streak || 0;
+  const biome = getBiomeLabel(count);
+  const wilt = getWiltFactor(forest.lastActiveDate);
+  const days = getDayCount(forest.createdAt);
+  const width = Math.min(forest.viewerWidth || 60, 80);
+
+  const art = renderPlainText(forest, width);
+
+  const statParts = [`**${count} tree${count === 1 ? "" : "s"}**`];
+  if (wilt > 0) {
+    const a = new Date(forest.lastActiveDate + "T00:00:00");
+    const b = new Date(new Date().toISOString().slice(0, 10) + "T00:00:00");
+    const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+    statParts.push(`**wilting (${idle}d idle)**`);
+  } else if (streak > 0) {
+    statParts.push(`**${streak}-day streak**`);
+  }
+  statParts.push(`**${biome}**`);
+
+  const lines = [
+    `<div align="center">`,
+    ``,
+    `[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)`,
+    ``,
+    statParts.join(" · "),
+    ``,
+    "```",
+    art,
+    "```",
+    ``,
+    `${forest.totalPrompts} prompts over ${days} day${days === 1 ? "" : "s"}`,
+    ``,
+    `<sub>Grown with <a href="https://github.com/Varun2009178/honeytree">honeytree</a> — a forest that grows in your terminal every time you use Claude Code</sub>`,
+    ``,
+    `</div>`,
+    ``,
+  ];
+
+  return lines.join("\n");
+}
+
+export async function generateForestMd() {
+  const forest = readForest();
+  if (!forest) {
+    console.error('No forest found. Run "honeytree init" first.');
+    process.exit(1);
+  }
+
+  const md = buildMarkdown(forest);
+  const outPath = path.resolve("FOREST.md");
+  fs.writeFileSync(outPath, md);
+
+  console.log(`Written to ${outPath}`);
+  console.log("Tip: run `honeytree badge` to generate the badge SVG too.");
+}

package/src/plant.js

@@ -1,7 +1,7 @@
 import { getSprite, TREE_TYPES } from "./sprites.js";
 import { createEmptyForest, readForest, writeForest } from "./state.js";
 
-const MIN_GAP = 2;
+const MIN_GAP = 4;
 const DEFAULT_WIDTH = 80;
 
 function getPlantWidth(forest) {
@@ -53,10 +53,33 @@ function nudgeGrowth(growth) {
   return Math.min(1, Math.round(nextGrowth * 100) / 100);
 }
 
+function daysBetween(dateA, dateB) {
+  const a = new Date(dateA + "T00:00:00");
+  const b = new Date(dateB + "T00:00:00");
+  return Math.round(Math.abs(b - a) / (24 * 60 * 60 * 1000));
+}
+
 export async function plant() {
   const forest = readForest() ?? createEmptyForest();
   const width = getPlantWidth(forest);
 
+  // Update streak
+  const today = new Date().toISOString().slice(0, 10);
+  if (forest.lastActiveDate) {
+    const gap = daysBetween(forest.lastActiveDate, today);
+    if (gap === 0) {
+      // Same day — streak stays (ensure at least 1)
+      forest.streak = Math.max(forest.streak || 0, 1);
+    } else if (gap === 1) {
+      forest.streak = (forest.streak || 1) + 1;
+    } else {
+      forest.streak = 1;
+    }
+  } else {
+    forest.streak = 1;
+  }
+  forest.lastActiveDate = today;
+
   for (const tree of forest.trees) {
     tree.growth = nudgeGrowth(tree.growth);
   }

package/src/renderer.js

@@ -13,10 +13,76 @@ export const SCENE_HEIGHT =
 
 const STATS_ACCENT = "#f5a50b";
 const STATS_TEXT = "#8e8a84";
+const STATS_WARN = "#c4653a";
+const STREAK_COLOR = "#e8a33a";
 const BAR_FILL = "#6cb95e";
 const BAR_EMPTY = "#3d3d3d";
 const MILESTONES = [10, 25, 50, 100, 250, 500, 1000];
 
+// Wilting — lerp toward dry brown when idle
+const WILT_TARGET = { r: 0x8a, g: 0x6a, b: 0x4a };
+
+function parseHex(hex) {
+  const h = hex.startsWith("#") ? hex.slice(1) : hex;
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+  };
+}
+
+function toHex({ r, g, b }) {
+  const c = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+  return `#${c(r)}${c(g)}${c(b)}`;
+}
+
+function wiltColor(hex, factor) {
+  if (factor <= 0) return hex;
+  const c = parseHex(hex);
+  return toHex({
+    r: c.r + (WILT_TARGET.r - c.r) * factor,
+    g: c.g + (WILT_TARGET.g - c.g) * factor,
+    b: c.b + (WILT_TARGET.b - c.b) * factor,
+  });
+}
+
+export function getWiltFactor(lastActiveDate) {
+  if (!lastActiveDate) return 0;
+  const today = new Date().toISOString().slice(0, 10);
+  const a = new Date(lastActiveDate + "T00:00:00");
+  const b = new Date(today + "T00:00:00");
+  const days = Math.round((b - a) / (24 * 60 * 60 * 1000));
+  if (days <= 0) return 0;
+  if (days === 1) return 0.25;
+  if (days === 2) return 0.45;
+  if (days === 3) return 0.65;
+  return Math.min(0.85, 0.65 + (days - 3) * 0.05);
+}
+
+// Fog — procedural haze that thickens with inactivity
+const FOG_CHARS = ["░", "░", "▒"];
+const FOG_COLOR_UPPER = "#9a9a9a";
+const FOG_COLOR_LOWER = "#6a6a6a";
+
+function applyFog(buffer, wilt, width) {
+  if (wilt <= 0) return;
+  // Higher wilt → lower threshold → more fog
+  const threshold = Math.max(3, Math.round(18 * (1 - wilt)));
+  const fogStart = SKY_ROWS - 2; // creep into lower sky
+  const fogEnd = SKY_ROWS + TREE_ROWS + GROUND_ROWS;
+
+  for (let y = Math.max(0, fogStart); y < fogEnd; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const h = hash(x * 31 + y * 97 + 12345);
+      if (h % threshold !== 0) continue;
+      const fogChar = FOG_CHARS[h % FOG_CHARS.length];
+      const blend = (y - fogStart) / (fogEnd - fogStart);
+      const fogColor = blend > 0.5 ? FOG_COLOR_LOWER : FOG_COLOR_UPPER;
+      buffer[y][x] = { char: fogChar, color: fogColor };
+    }
+  }
+}
+
 // Biomes evolve as the forest grows — never resets, only gets richer
 const BIOMES = [
   { // 0-9: sparse clearing
@@ -116,11 +182,19 @@ function getNextTreeType(treeCount) {
   return TREE_TYPES[treeCount % TREE_TYPES.length];
 }
 
-function getDayCount(createdAt) {
-  const created = new Date(createdAt).getTime();
-  const diff = Date.now() - created;
-  const days = Math.floor(diff / (24 * 60 * 60 * 1000));
-  return Math.max(1, days + 1);
+function buildStreakSegment(forest) {
+  const wilt = getWiltFactor(forest.lastActiveDate);
+  const streak = forest.streak || 0;
+
+  if (wilt > 0) {
+    const a = new Date(forest.lastActiveDate + "T00:00:00");
+    const b = new Date(new Date().toISOString().slice(0, 10) + "T00:00:00");
+    const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+    return chalk.hex(STATS_WARN)(`wilting (${idle}d idle)`);
+  }
+
+  if (streak <= 0) return chalk.hex(STATS_TEXT)("no streak");
+  return chalk.hex(STREAK_COLOR)(`${streak}-day streak`);
 }
 
 function buildStatsLine(forest, biome) {
@@ -136,10 +210,10 @@ function buildStatsLine(forest, biome) {
   return (
     chalk.hex(STATS_ACCENT)(" honeytree") +
     chalk.hex(STATS_TEXT)(
-      ` · ${treeCount} tree${treeCount === 1 ? "" : "s"} · ${getDayCount(
-        forest.createdAt,
-      )} day${getDayCount(forest.createdAt) === 1 ? "" : "s"} · `,
+      ` · ${treeCount} tree${treeCount === 1 ? "" : "s"} · `,
     ) +
+    buildStreakSegment(forest) +
+    chalk.hex(STATS_TEXT)(" · ") +
     bar +
     chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`) +
     chalk.hex("#555555")(` [${biome.label}]`)
@@ -151,6 +225,7 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
   const buffer = createBuffer(width);
   const groundStart = SKY_ROWS + TREE_ROWS;
   const biome = getBiome(forest.trees.length);
+  const wilt = getWiltFactor(forest.lastActiveDate);
 
   for (const star of generateStars(width, biome, options.twinkleSeed ?? 0)) {
     buffer[star.y][star.x] = { char: star.char, color: star.color };
@@ -170,11 +245,19 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
     compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
   }
 
+  applyFog(buffer, wilt, width);
+
   const lines = [];
   for (let y = 0; y < SCENE_HEIGHT - SPACER_ROWS - STATS_ROWS; y += 1) {
     let line = "";
     for (const cell of buffer[y]) {
-      line += cell.color ? chalk.hex(cell.color)(cell.char) : cell.char;
+      if (!cell.color) {
+        line += cell.char;
+      } else {
+        // Apply wilting to tree rows and ground (skip sky)
+        const color = wilt > 0 && y >= SKY_ROWS ? wiltColor(cell.color, wilt) : cell.color;
+        line += chalk.hex(color)(cell.char);
+      }
     }
     lines.push(line);
   }
@@ -184,3 +267,36 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
 
   return lines.join("\n");
 }
+
+export function renderPlainText(forest, width = 60) {
+  const w = Math.max(40, Math.min(width, 80));
+  const buffer = createBuffer(w);
+  const groundStart = SKY_ROWS + TREE_ROWS;
+  const biome = getBiome(forest.trees.length);
+
+  for (const star of generateStars(w, biome, 0)) {
+    buffer[star.y][star.x] = { char: star.char, color: star.color };
+  }
+
+  for (let rowIndex = 0; rowIndex < GROUND_ROWS; rowIndex += 1) {
+    for (let x = 0; x < w; x += 1) {
+      buffer[groundStart + rowIndex][x] = { char: "█", color: "#333" };
+    }
+  }
+
+  const treeBaseY = groundStart - 1;
+  for (const tree of forest.trees) {
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+  }
+
+  const lines = [];
+  for (let y = 0; y < SCENE_HEIGHT - SPACER_ROWS - STATS_ROWS; y += 1) {
+    let line = "";
+    for (const cell of buffer[y]) {
+      line += cell.char;
+    }
+    lines.push(line.trimEnd());
+  }
+
+  return lines.join("\n");
+}

package/src/state.js

@@ -27,6 +27,8 @@ export function createEmptyForest() {
     trees: [],
     totalPrompts: 0,
     createdAt: new Date().toISOString(),
+    lastActiveDate: new Date().toISOString().slice(0, 10),
+    streak: 0,
   };
 }
 

package/src/viewer.js

@@ -64,10 +64,12 @@ export async function viewer() {
   }
 
   // Save terminal width so plant knows how wide to spread trees
+  let ignoreNextChange = false;
   function syncWidth() {
     const cols = process.stdout.columns || 80;
     if (forest.viewerWidth !== cols) {
       forest.viewerWidth = cols;
+      ignoreNextChange = true;
       writeForest(forest);
     }
   }
@@ -78,6 +80,8 @@ export async function viewer() {
   renderForest(forest);
 
   let lastMaxId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
+  let lastTotalPrompts = forest.totalPrompts;
+  let animating = false;
 
   const cleanup = () => {
     showCursor();
@@ -96,21 +100,70 @@ export async function viewer() {
     renderForest(forest);
   });
 
-  let debounceTimer;
-  fs.watch(forestFile, () => {
-    clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(async () => {
-      const updated = readForest();
-      if (!updated) return;
-
-      const nextMaxId = updated.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
-      forest = updated;
-      if (nextMaxId > lastMaxId) {
-        lastMaxId = nextMaxId;
-        await animateNewTree(forest, nextMaxId);
-      } else {
-        renderForest(forest);
+  // Check for changes — used by both fs.watch and polling fallback
+  async function checkForUpdates() {
+    if (animating) return;
+
+    if (ignoreNextChange) {
+      ignoreNextChange = false;
+      return;
+    }
+
+    const updated = readForest();
+    if (!updated) return;
+
+    // Only re-render if something actually changed
+    if (updated.totalPrompts === lastTotalPrompts) return;
+
+    const nextMaxId = updated.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
+    forest = updated;
+    lastTotalPrompts = forest.totalPrompts;
+
+    if (nextMaxId > lastMaxId) {
+      lastMaxId = nextMaxId;
+      animating = true;
+      await animateNewTree(forest, nextMaxId);
+      animating = false;
+    } else {
+      renderForest(forest);
+    }
+  }
+
+  // fs.watch can drop events on macOS after atomic renames, so
+  // use it for fast response but also poll as a reliable fallback
+  function startWatcher() {
+    try {
+      const watcher = fs.watch(forestFile, () => {
+        checkForUpdates();
+      });
+      watcher.on("error", () => {});
+      return watcher;
+    } catch {
+      return null;
+    }
+  }
+
+  let watcher = startWatcher();
+
+  // Poll every 800ms as fallback — cheap since it only reads if mtime changed
+  let lastMtime = 0;
+  try {
+    lastMtime = fs.statSync(forestFile).mtimeMs;
+  } catch {}
+
+  setInterval(() => {
+    try {
+      const mtime = fs.statSync(forestFile).mtimeMs;
+      if (mtime !== lastMtime) {
+        lastMtime = mtime;
+        checkForUpdates();
+
+        // Re-establish watcher in case rename killed it
+        if (watcher) {
+          try { watcher.close(); } catch {}
+        }
+        watcher = startWatcher();
       }
-    }, 100);
-  });
+    } catch {}
+  }, 800);
 }