honeytree 1.2.0 → 1.2.1

package/src/components/ForestApp.js

@@ -0,0 +1,404 @@
+import React, { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+import { getAuth, isLoggedIn } from "../auth.js";
+import { getRewards, syncRewards, uncelebratedUnlocked, markCelebrated } from "../rewards.js";
+import UnlockCelebration from "./UnlockCelebration.js";
+
+import ForestScene from "./ForestScene.js";
+import StatsBar from "./StatsBar.js";
+import TreeInfoPopup from "./TreeInfoPopup.js";
+
+import { getForestFile, readForest, writeForest } from "../state.js";
+import { migrateLayout } from "../migrate.js";
+import { getVirtualWidth } from "../plant.js";
+import { getAnimationFrames } from "../animation.js";
+import { createForestWatcher } from "../viewer2d.js";
+import { readActiveSession, isStale } from "../session.js";
+import { readNewTokens } from "../transcript.js";
+import { tokensToTree } from "../growth.js";
+import LiveTree from "./LiveTree.js";
+
+const h = React.createElement;
+const PAN_STEP = 4;
+
+export default function ForestApp() {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+
+  const forestFile = getForestFile();
+
+  const [forest, setForest] = useState(() => {
+    const f = readForest();
+    if (!f || !fs.existsSync(forestFile)) {
+      console.error('No forest found. Run "honeytree init" first.');
+      process.exit(1);
+    }
+    if (f && (!f.layoutVersion || f.layoutVersion < 2)) {
+      const termWidth = stdout?.columns || 80;
+      migrateLayout(f, termWidth);
+    }
+    return f;
+  });
+
+  const [viewportX, setViewportX] = useState(forest.viewportX || 0);
+  const [windTick, setWindTick] = useState(0);
+  const [termWidth, setTermWidth] = useState(stdout?.columns || 80);
+  const [selectedTreeIdx, setSelectedTreeIdx] = useState(-1);
+  const [showPopup, setShowPopup] = useState(false);
+  const [animating, setAnimating] = useState(false);
+  const [spriteOverride, setSpriteOverride] = useState(null);
+  const [groundOverlay, setGroundOverlay] = useState(null);
+  const [groundPulse, setGroundPulse] = useState(false);
+  const [milestonePrompt, setMilestonePrompt] = useState(null);
+  const [rewards, setRewards] = useState(() => getRewards());
+  const [celebrationQueue, setCelebrationQueue] = useState(() => uncelebratedUnlocked());
+
+  const [activeTree, setActiveTree] = useState(null);
+  const [liveTokens, setLiveTokens] = useState(0);
+  const tailRef = useRef({ path: null, offset: 0, tokens: 0, startedAt: 0 });
+
+  const ignoreNextChange = useRef(false);
+  const lastMaxId = useRef(forest.trees.reduce((max, t) => Math.max(max, t.id), 0));
+  const lastTotalPrompts = useRef(forest.totalPrompts);
+  const forestRef = useRef(forest);
+  forestRef.current = forest;
+  const viewportXRef = useRef(viewportX);
+  viewportXRef.current = viewportX;
+
+  // Fetch rewards from server (async, non-blocking)
+  useEffect(() => {
+    if (isLoggedIn()) {
+      syncRewards().then((r) => {
+        if (r) {
+          setRewards(r);
+          setCelebrationQueue(uncelebratedUnlocked());
+        }
+      }).catch(() => {});
+    }
+  }, []);
+
+  // Sync width to disk
+  const syncWidth = useCallback(() => {
+    const cols = stdout?.columns || 80;
+    const f = forestRef.current;
+    if (f.viewerWidth !== cols) {
+      f.viewerWidth = cols;
+      ignoreNextChange.current = true;
+      writeForest(f);
+    }
+  }, [stdout]);
+
+  useEffect(() => {
+    syncWidth();
+  }, [syncWidth]);
+
+  // Clamp viewport helper
+  const clampViewport = useCallback((x) => {
+    const vw = getVirtualWidth(forestRef.current.trees.length, termWidth);
+    return Math.max(0, Math.min(x, Math.max(0, vw - termWidth)));
+  }, [termWidth]);
+
+  // Get visible trees in viewport for selection
+  const getVisibleTrees = useCallback(() => {
+    const vpEnd = viewportX + termWidth;
+    return forest.trees
+      .filter((t) => t.x >= viewportX && t.x < vpEnd)
+      .sort((a, b) => a.x - b.x);
+  }, [forest, viewportX, termWidth]);
+
+  // Wind interval
+  useEffect(() => {
+    const id = setInterval(() => {
+      if (!animating) {
+        setWindTick((t) => t + 1);
+      }
+    }, 2500);
+    return () => clearInterval(id);
+  }, [animating]);
+
+  // Live growth: tail the active Claude Code session transcript.
+  useEffect(() => {
+    const id = setInterval(() => {
+      const s = readActiveSession();
+      if (!s || isStale(s)) {
+        if (tailRef.current.path) {
+          tailRef.current = { path: null, offset: 0, tokens: 0, startedAt: 0 };
+          setActiveTree(null);
+          setLiveTokens(0);
+        }
+        return;
+      }
+      if (tailRef.current.path !== s.transcript_path || tailRef.current.startedAt !== s.turnStartedAt) {
+        tailRef.current = {
+          path: s.transcript_path,
+          offset: s.baselineOffset || 0,
+          tokens: 0,
+          startedAt: s.turnStartedAt,
+        };
+      }
+      const { tokens, newOffset } = readNewTokens(tailRef.current.path, tailRef.current.offset);
+      tailRef.current.offset = newOffset;
+      tailRef.current.tokens += tokens;
+      const shape = tokensToTree(tailRef.current.tokens);
+      setLiveTokens(tailRef.current.tokens);
+      setActiveTree({
+        id: -1,
+        type: s.type || "oak",
+        x: typeof s.x === "number" ? s.x : 0,
+        growth: shape.growth,
+        heightBonus: shape.heightBonus,
+        variant: s.variant ?? null,
+        plantedAt: new Date().toISOString(),
+      });
+    }, 1000);
+    return () => clearInterval(id);
+  }, []);
+
+  // Resize handler
+  useEffect(() => {
+    const onResize = () => {
+      const cols = stdout?.columns || 80;
+      setTermWidth(cols);
+      syncWidth();
+    };
+    stdout?.on("resize", onResize);
+    return () => stdout?.off("resize", onResize);
+  }, [stdout, syncWidth]);
+
+  // Animate new tree
+  const animateNewTree = useCallback(async (updatedForest, newTreeId) => {
+    const tree = updatedForest.trees.find((t) => t.id === newTreeId);
+    if (!tree) return;
+
+    const FRAME_COUNT = 40;
+    const FRAME_DELAY = 125;
+
+    const frames = getAnimationFrames(tree.type, tree.growth, FRAME_COUNT);
+
+    for (let i = 0; i < frames.length; i++) {
+      const frameData = frames[i];
+      setSpriteOverride({ treeId: tree.id, sprite: frameData.sprite });
+      setGroundPulse(frameData.groundPulse ?? false);
+      if (frameData.groundOverlay) {
+        setGroundOverlay({ treeX: tree.x, overlays: frameData.groundOverlay });
+      } else {
+        setGroundOverlay(null);
+      }
+      setWindTick(i);
+      await new Promise((r) => setTimeout(r, FRAME_DELAY));
+    }
+
+    setSpriteOverride(null);
+    setGroundOverlay(null);
+    setGroundPulse(false);
+  }, []);
+
+  // File watcher + polling for forest changes
+  useEffect(() => {
+    const checkForUpdates = async () => {
+      if (animating) return;
+      if (ignoreNextChange.current) {
+        ignoreNextChange.current = false;
+        return;
+      }
+      const updated = readForest();
+      if (!updated) return;
+      if (updated.totalPrompts === lastTotalPrompts.current) return;
+
+      const nextMaxId = updated.trees.reduce((max, t) => Math.max(max, t.id), 0);
+      lastTotalPrompts.current = updated.totalPrompts;
+      setForest(updated);
+      forestRef.current = updated;
+      setActiveTree(null);
+      setLiveTokens(0);
+      tailRef.current = { path: null, offset: 0, tokens: 0, startedAt: 0 };
+
+      // Check for milestone flag
+      try {
+        const milestoneFile = path.join(os.homedir(), ".honeydew", "milestone.json");
+        if (fs.existsSync(milestoneFile)) {
+          const milestone = JSON.parse(fs.readFileSync(milestoneFile, "utf8"));
+          setMilestonePrompt(milestone);
+        }
+      } catch {}
+
+      if (nextMaxId > lastMaxId.current) {
+        lastMaxId.current = nextMaxId;
+        const newTree = updated.trees.find((t) => t.id === nextMaxId);
+        if (newTree) {
+          const tw = stdout?.columns || 80;
+          const vw = getVirtualWidth(updated.trees.length, tw);
+          const newVpx = Math.max(0, Math.min(newTree.x - Math.floor(tw / 2), Math.max(0, vw - tw)));
+          setViewportX(newVpx);
+        }
+        setAnimating(true);
+        await animateNewTree(updated, nextMaxId);
+        setAnimating(false);
+      }
+    };
+
+    const watcher = createForestWatcher(forestFile, () => checkForUpdates());
+
+    let lastMtime = 0;
+    try { lastMtime = fs.statSync(forestFile).mtimeMs; } catch {}
+
+    const pollId = setInterval(() => {
+      try {
+        const mtime = fs.statSync(forestFile).mtimeMs;
+        if (mtime !== lastMtime) {
+          lastMtime = mtime;
+          checkForUpdates();
+        }
+      } catch {}
+    }, 800);
+
+    return () => {
+      if (watcher) try { watcher.close(); } catch {}
+      clearInterval(pollId);
+    };
+  }, [forestFile, animating, animateNewTree, stdout]);
+
+  // Save viewport on unmount
+  useEffect(() => {
+    return () => {
+      const f = forestRef.current;
+      f.viewportX = viewportXRef.current;
+      ignoreNextChange.current = true;
+      writeForest(f);
+    };
+  }, []);
+
+  // Keyboard input
+  useInput((input, key) => {
+    if (celebrationQueue.length > 0) return;
+
+    if (milestonePrompt) {
+      const milestoneFile = path.join(os.homedir(), ".honeydew", "milestone.json");
+      if (input === "y") {
+        // Open checkout in browser
+        const auth = getAuth();
+        if (auth && auth.access_token) {
+          fetch("https://tryhoney.xyz/api/checkout", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${auth.access_token}`,
+            },
+          })
+            .then((r) => r.json())
+            .then(({ url }) => {
+              if (url) {
+                try { execSync(`open "${url}"`); } catch {
+                  try { execSync(`xdg-open "${url}"`); } catch {}
+                }
+              }
+            })
+            .catch(() => {});
+        }
+        try { fs.unlinkSync(milestoneFile); } catch {}
+        setMilestonePrompt(null);
+      } else if (input === "n") {
+        try { fs.unlinkSync(milestoneFile); } catch {}
+        setMilestonePrompt(null);
+      }
+      return;
+    }
+
+    if (showPopup) {
+      if (key.escape) {
+        setShowPopup(false);
+      }
+      return;
+    }
+
+    if (input === "q") {
+      const f = forestRef.current;
+      f.viewportX = viewportXRef.current;
+      ignoreNextChange.current = true;
+      writeForest(f);
+      exit();
+      return;
+    }
+
+    if (key.leftArrow) {
+      setViewportX((x) => clampViewport(x - PAN_STEP));
+      return;
+    }
+    if (key.rightArrow) {
+      setViewportX((x) => clampViewport(x + PAN_STEP));
+      return;
+    }
+
+    if (key.upArrow) {
+      const visible = getVisibleTrees();
+      if (visible.length === 0) return;
+      setSelectedTreeIdx((prev) => {
+        if (prev <= 0) return visible.length - 1;
+        return prev - 1;
+      });
+      return;
+    }
+    if (key.downArrow || key.tab) {
+      const visible = getVisibleTrees();
+      if (visible.length === 0) return;
+      setSelectedTreeIdx((prev) => {
+        if (prev < 0 || prev >= visible.length - 1) return 0;
+        return prev + 1;
+      });
+      return;
+    }
+
+    if (key.return) {
+      const visible = getVisibleTrees();
+      if (selectedTreeIdx >= 0 && selectedTreeIdx < visible.length) {
+        setShowPopup(true);
+      }
+      return;
+    }
+  });
+
+  const visibleTrees = getVisibleTrees();
+  const selectedTree = selectedTreeIdx >= 0 && selectedTreeIdx < visibleTrees.length
+    ? visibleTrees[selectedTreeIdx]
+    : null;
+
+  const liveForest = activeTree
+    ? { ...forest, trees: [...forest.trees, activeTree] }
+    : forest;
+
+  if (celebrationQueue.length > 0) {
+    const current = celebrationQueue[0];
+    return h(UnlockCelebration, {
+      varietyKey: current,
+      onDismiss: () => {
+        markCelebrated(current);
+        setCelebrationQueue((q) => q.slice(1));
+      },
+    });
+  }
+
+  return h(Box, { flexDirection: "column" },
+    h(ForestScene, {
+      forest: liveForest,
+      viewportX,
+      windTick,
+      termWidth,
+      spriteOverride,
+      groundOverlay,
+      groundPulse,
+      rewards,
+    }),
+    h(StatsBar, { forest, viewportX, termWidth, rewards }),
+    activeTree ? h(LiveTree, { tokens: liveTokens }) : null,
+    showPopup && selectedTree ? h(TreeInfoPopup, { tree: selectedTree }) : null,
+    milestonePrompt ? h(Box, { flexDirection: "column", paddingX: 1 },
+      h(Text, { color: "green", bold: true },
+        `${milestonePrompt.totalPrompts} virtual trees! You've unlocked a real tree planting ($1). Plant one? (y/n)`
+      ),
+    ) : null,
+  );
+}

package/src/components/ForestScene.js

@@ -0,0 +1,26 @@
+import React, { useMemo } from "react";
+import { Text } from "ink";
+
+import { renderFrame } from "../renderer.js";
+import { getVirtualWidth } from "../plant.js";
+
+const h = React.createElement;
+
+export default function ForestScene({ forest, viewportX, windTick, termWidth, spriteOverride, groundOverlay, groundPulse, rewards }) {
+  const frame = useMemo(() => {
+    const vw = getVirtualWidth(forest.trees.length, termWidth);
+    return renderFrame(forest, termWidth, {
+      twinkleSeed: windTick,
+      viewportX,
+      virtualWidth: vw,
+      windTick,
+      includeStats: false,
+      spriteOverride: spriteOverride ?? undefined,
+      groundOverlay: groundOverlay ?? undefined,
+      groundPulse: groundPulse ?? false,
+      rewards: rewards ?? undefined,
+    });
+  }, [forest, viewportX, windTick, termWidth, spriteOverride, groundOverlay, groundPulse, rewards]);
+
+  return h(Text, null, frame);
+}

package/src/components/LiveTree.js

@@ -0,0 +1,14 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+const h = React.createElement;
+
+// Small status line shown while a live turn is streaming.
+export default function LiveTree({ tokens }) {
+  return h(
+    Box,
+    {},
+    h(Text, { color: "green" }, "● live "),
+    h(Text, { color: "yellow" }, `· ${tokens.toLocaleString()} tok`),
+  );
+}

package/src/components/StatsBar.js

@@ -0,0 +1,70 @@
+import React, { useMemo } from "react";
+import { Box, Text } from "ink";
+
+import { getStatsData } from "../renderer.js";
+import { getVirtualWidth } from "../plant.js";
+
+const h = React.createElement;
+
+const STATS_ACCENT = "#f5a50b";
+const STATS_TEXT = "#8e8a84";
+const STATS_WARN = "#c4653a";
+const STREAK_COLOR = "#e8a33a";
+const BAR_FILL = "#6cb95e";
+const BAR_EMPTY = "#3d3d3d";
+
+export default function StatsBar({ forest, viewportX, termWidth, rewards }) {
+  const vw = getVirtualWidth(forest.trees.length, termWidth);
+  const stats = useMemo(
+    () => getStatsData(forest, viewportX, vw, termWidth),
+    [forest, viewportX, vw, termWidth],
+  );
+
+  const barWidth = 12;
+  const filledWidth = Math.max(0, Math.min(barWidth, Math.round(stats.progress * barWidth)));
+
+  // Minimap
+  let minimap = null;
+  if (stats.virtualWidth > stats.termWidth) {
+    const mapWidth = 12;
+    const viewFraction = stats.termWidth / stats.virtualWidth;
+    const thumbWidth = Math.max(1, Math.round(viewFraction * mapWidth));
+    const maxOffset = stats.virtualWidth - stats.termWidth;
+    const thumbPos = maxOffset > 0
+      ? Math.round((stats.viewportX / maxOffset) * (mapWidth - thumbWidth))
+      : 0;
+    const mapBar =
+      "─".repeat(thumbPos) +
+      "═".repeat(thumbWidth) +
+      "─".repeat(mapWidth - thumbPos - thumbWidth);
+    minimap = h(Text, null,
+      h(Text, { color: STATS_TEXT }, " ["),
+      h(Text, { color: BAR_FILL }, mapBar),
+      h(Text, { color: STATS_TEXT }, "]"),
+    );
+  }
+
+  const streakSegment = stats.wilt > 0
+    ? h(Text, { color: STATS_WARN }, `wilting (${stats.idleDays}d idle)`)
+    : stats.streak > 0
+      ? h(Text, { color: STREAK_COLOR }, `${stats.streak}-day streak`)
+      : h(Text, { color: STATS_TEXT }, "no streak");
+
+  return h(Box, { flexDirection: "column" },
+    h(Box, null,
+      h(Text, { color: STATS_ACCENT }, " honeytree"),
+      h(Text, { color: STATS_TEXT }, ` · ${stats.treeCount} tree${stats.treeCount === 1 ? "" : "s"} · `),
+      streakSegment,
+      h(Text, { color: STATS_TEXT }, " · "),
+      h(Text, { color: BAR_FILL }, "█".repeat(filledWidth)),
+      h(Text, { color: BAR_EMPTY }, "░".repeat(barWidth - filledWidth)),
+      h(Text, { color: STATS_TEXT }, ` next: ${stats.nextTreeType}`),
+      h(Text, { color: "#555555" }, ` [${stats.biomeName}]`),
+      minimap,
+    ),
+    h(Box, null,
+      h(Text, { color: "#555555" }, " ← → pan  · ↑↓ select tree  · enter info  · q quit  ·  "),
+      h(Text, { color: STATS_ACCENT }, "honeytree badge"),
+    ),
+  );
+}

package/src/components/TreeInfoPopup.js

@@ -0,0 +1,28 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+const h = React.createElement;
+
+export default function TreeInfoPopup({ tree }) {
+  if (!tree) return null;
+
+  const growthPct = Math.round(tree.growth * 100);
+  const plantedDate = tree.plantedAt
+    ? new Date(tree.plantedAt).toLocaleDateString()
+    : "unknown";
+
+  let age = "";
+  if (tree.plantedAt) {
+    const days = Math.floor((Date.now() - new Date(tree.plantedAt).getTime()) / (24 * 60 * 60 * 1000));
+    age = days === 0 ? "today" : days === 1 ? "1 day" : `${days} days`;
+  }
+
+  return h(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f5a50b", paddingX: 1 },
+    h(Text, { bold: true, color: "#f5a50b" }, ` ${tree.type} `),
+    h(Text, { color: "#8e8a84" }, `  Growth:  ${growthPct}%`),
+    h(Text, { color: "#8e8a84" }, `  Planted: ${plantedDate}`),
+    age ? h(Text, { color: "#8e8a84" }, `  Age:     ${age}`) : null,
+    h(Text, { color: "#8e8a84" }, `  ID:      ${tree.id}`),
+    h(Text, { dimColor: true }, `  [esc] close`),
+  );
+}

package/src/components/UnlockCelebration.js

@@ -0,0 +1,40 @@
+import React from "react";
+import { Box, Text, useInput } from "ink";
+import { VARIETIES } from "../varieties.js";
+
+const h = React.createElement;
+
+// ASCII reveal art per variety (screenshot-worthy, terminal-safe).
+const ART = {
+  cherry: "  .::.\n.:(@@):.\n :(@@): \n   ||   ",
+  pine: "    ^\n   /^\\\n  /^^^\\\n /^^^^^\\\n   |||  ",
+  oak: "   ___\n  (###)\n (#####)\n  (###)\n   |||  ",
+  ancient: "  *___*\n (#####)\n(#######)\n (#####)\n  |||||  ",
+  mythic: "  *. .*\n .*###*.\n*#######*\n .*###*.\n  |||||  ",
+};
+
+export function celebrationFor(key) {
+  const v = VARIETIES.find((x) => x.key === key);
+  return {
+    label: v ? v.label : key,
+    art: ART[key] || "  ###\n (###)\n  |||",
+  };
+}
+
+// Full-screen celebration. Calls onDismiss() when the user presses any key.
+export default function UnlockCelebration({ varietyKey, onDismiss }) {
+  const { label, art } = celebrationFor(varietyKey);
+  useInput(() => onDismiss());
+
+  return h(
+    Box,
+    { flexDirection: "column", alignItems: "center", justifyContent: "center", height: 18, width: "100%" },
+    h(Text, { color: "#f5a50b", bold: true }, "✦  NEW TREE VARIETY UNLOCKED  ✦"),
+    h(Box, { height: 1 }),
+    h(Text, { color: "#b388ff" }, art),
+    h(Box, { height: 1 }),
+    h(Text, { bold: true }, label),
+    h(Box, { height: 1 }),
+    h(Text, { dimColor: true }, "Screenshot this — then press any key to enter your forest")
+  );
+}

package/src/growth.js

@@ -0,0 +1,32 @@
+// Pure mapping from a turn's output-token count to a tree's shape.
+// Tunable: change these to reshape the forest's "honesty" curve.
+export const GROWTH = {
+  SAPLING_MAX: 250,
+  FULL_TOKENS: 1500,
+  MONSTER_TOKENS: 4000,
+  MAX_HEIGHT_BONUS: 4,
+};
+
+export function tokensToTree(tokens) {
+  const n = Number.isFinite(tokens) && tokens > 0 ? tokens : 0;
+
+  let growth;
+  if (n < GROWTH.SAPLING_MAX) {
+    growth = 0.15 + (n / GROWTH.SAPLING_MAX) * 0.2; // 0.15 .. 0.35
+  } else if (n < GROWTH.FULL_TOKENS) {
+    const r = (n - GROWTH.SAPLING_MAX) / (GROWTH.FULL_TOKENS - GROWTH.SAPLING_MAX);
+    growth = 0.35 + r * 0.65; // 0.35 .. 1.0
+  } else {
+    growth = 1;
+  }
+
+  let heightBonus = 0;
+  if (n > GROWTH.FULL_TOKENS) {
+    const over =
+      (n - GROWTH.FULL_TOKENS) / (GROWTH.MONSTER_TOKENS - GROWTH.FULL_TOKENS);
+    heightBonus = Math.min(GROWTH.MAX_HEIGHT_BONUS, Math.max(1, Math.ceil(over * GROWTH.MAX_HEIGHT_BONUS)));
+  }
+
+  // Variant (species/look) is owned by the variety system, not token count.
+  return { growth: Math.min(1, Math.round(growth * 100) / 100), heightBonus, variant: null };
+}

package/src/init.js

@@ -20,7 +20,17 @@ const HONEYDEW_STOP_HOOK = {
   hooks: [
     {
       type: "command",
-      command: "honeytree plant",
+      command: "honeytree __tick",
+    },
+  ],
+};
+
+const HONEYDEW_SESSION_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "honeytree __session",
     },
   ],
 };
@@ -28,11 +38,34 @@ const HONEYDEW_STOP_HOOK = {
 function hasHoneydewHook(settings) {
   return (
     settings?.hooks?.Stop?.some((entry) =>
-      entry?.hooks?.some((hook) => hook?.command === "honeytree plant"),
+      entry?.hooks?.some((hook) => hook?.command === "honeytree __tick"),
     ) ?? false
   );
 }
 
+function hasSessionHook(settings) {
+  return (
+    settings?.hooks?.UserPromptSubmit?.some((entry) =>
+      entry?.hooks?.some((hook) => hook?.command === "honeytree __session"),
+    ) ?? false
+  );
+}
+
+// Rewrite any legacy `honeytree plant` Stop hook to the new hidden `__tick`.
+// Returns true if anything changed.
+function migrateLegacyHook(settings) {
+  let changed = false;
+  for (const entry of settings?.hooks?.Stop ?? []) {
+    for (const hook of entry?.hooks ?? []) {
+      if (hook?.command === "honeytree plant") {
+        hook.command = "honeytree __tick";
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+
 export async function init() {
   const honeydewDir = getHoneydewDir();
   fs.mkdirSync(honeydewDir, { recursive: true });
@@ -72,6 +105,12 @@ export async function init() {
   settings.hooks ??= {};
   settings.hooks.Stop ??= [];
 
+  const migrated = migrateLegacyHook(settings);
+  if (migrated) {
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    console.log(`Migrated legacy honeytree hook to __tick in ${settingsPath}`);
+  }
+
   if (hasHoneydewHook(settings)) {
     console.log(`Claude Code hook already configured in ${settingsPath}`);
   } else {
@@ -80,6 +119,13 @@ export async function init() {
     console.log(`Added honeytree Stop hook to ${settingsPath}`);
   }
 
+  settings.hooks.UserPromptSubmit ??= [];
+  if (!hasSessionHook(settings)) {
+    settings.hooks.UserPromptSubmit.push(HONEYDEW_SESSION_HOOK);
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    console.log(`Added honeytree UserPromptSubmit hook to ${settingsPath}`);
+  }
+
   console.log("");
   console.log("Setup complete.");
   console.log("Run `honeytree` in a separate terminal to watch the forest grow.");