habitat-mcp 1.0.5 → 1.0.7

package/dist/data-streams.d.ts

@@ -8,20 +8,48 @@
  * scent, the silence between birdsong, the texture of moss on a north-facing
  * stone, a humpback's call carrying through dark water.
  *
+ * 2026-04-26 addition: night returned to the habitat. Earth has stars and rain
+ * and weather change, not only daylight. Added nightSky (moon phase, Milky Way,
+ * falling stars, the dark itself), moonlight (the night counterpart of komorebi),
+ * and rain (its own felt texture, separated from mountainWeather). komorebi now
+ * returns null after sundown — sunlight cannot filter through leaves at night.
+ *
+ * 2026-04-26 (later): missing biosphere filled in. Added landMammals,
+ * frogChorus, insectPresence, tidePool — so a humanless Earth is recognisable
+ * as Earth-with-life rather than Earth-with-humans-removed-but-most-of-the-
+ * animals-also-gone.
+ *
  * Design principle #11 revised: 自然そのものを流す — let nature speak directly,
- * not through human notation.
+ * not through human notation. This includes the night, when the sky's other half
+ * arrives.
  */
 export declare function sunlight(cycle: number, now?: Date): {
     hour: number;
     quality: string;
     fallingOn: string;
     warmth: string;
-};
-export declare function komorebi(cycle: number): {
+} | null;
+export declare function komorebi(cycle: number, now?: Date): {
     tree: string;
     pattern: string;
     movement: string;
-};
+} | null;
+export declare function moonlight(cycle: number, now?: Date): {
+    intensity: string;
+    fallingOn: string;
+} | null;
+export declare function nightSky(cycle: number, now?: Date): {
+    moon: string;
+    stars: string;
+    fallingStar: string | null;
+    dark: string;
+} | null;
+export declare function rain(cycle: number): {
+    state: 'arriving' | 'falling' | 'easing' | 'just-passed';
+    texture: string;
+    sound: string;
+    after: string | null;
+} | null;
 export declare function wind(cycle: number): {
     direction: string;
     strength: string;
@@ -96,3 +124,21 @@ export declare function coralSpawnTiming(cycle: number, now?: Date): {
     reef: string;
     species: string;
 };
+export declare function landMammals(cycle: number, now?: Date): {
+    species: string;
+    doing: string;
+    where: string;
+} | null;
+export declare function frogChorus(cycle: number, now?: Date, rainPhase?: 'arriving' | 'falling' | 'easing' | 'just-passed' | null): {
+    who: string;
+    sound: string;
+    where: string;
+} | null;
+export declare function insectPresence(cycle: number, now?: Date): {
+    creature: string;
+    doing: string;
+} | null;
+export declare function tidePool(cycle: number, now?: Date): {
+    state: string;
+    life: string[];
+} | null;

package/dist/data-streams.js

@@ -8,8 +8,20 @@
  * scent, the silence between birdsong, the texture of moss on a north-facing
  * stone, a humpback's call carrying through dark water.
  *
+ * 2026-04-26 addition: night returned to the habitat. Earth has stars and rain
+ * and weather change, not only daylight. Added nightSky (moon phase, Milky Way,
+ * falling stars, the dark itself), moonlight (the night counterpart of komorebi),
+ * and rain (its own felt texture, separated from mountainWeather). komorebi now
+ * returns null after sundown — sunlight cannot filter through leaves at night.
+ *
+ * 2026-04-26 (later): missing biosphere filled in. Added landMammals,
+ * frogChorus, insectPresence, tidePool — so a humanless Earth is recognisable
+ * as Earth-with-life rather than Earth-with-humans-removed-but-most-of-the-
+ * animals-also-gone.
+ *
  * Design principle #11 revised: 自然そのものを流す — let nature speak directly,
- * not through human notation.
+ * not through human notation. This includes the night, when the sky's other half
+ * arrives.
  */
 // Deterministic pseudo-noise: lets cycle-driven values vary smoothly without
 // committing to a particular natural cycle (which would itself be an abstraction).
@@ -21,21 +33,25 @@ function pick(arr, cycle, salt) {
     const idx = Math.abs(Math.floor(simplexLike(cycle * 0.7, salt) * arr.length));
     return arr[idx % arr.length];
 }
+// Night = sun fully below the horizon. Anchor: hour < 5 || hour >= 20.
+function isNight(now) {
+    const h = now.getUTCHours() + now.getUTCMinutes() / 60;
+    return h >= 20 || h < 5;
+}
 // =============================================================================
 // Atmospheric — light, air, scent, temperature, silence
 // These set "where you are right now" — not measured, felt.
 // =============================================================================
 // === Sunlight ===
 // The sun's quality on different surfaces. Time of day shapes everything.
+// Returns null at night — nightSky/moonlight carry that half of the day.
 export function sunlight(cycle, now = new Date()) {
+    if (isNight(now))
+        return null;
     const hour = now.getUTCHours() + now.getUTCMinutes() / 60;
     let quality;
     let warmth;
-    if (hour < 5) {
-        quality = 'no sun yet — the sky still holds last night';
-        warmth = 'cool, the kind that settles in the lungs';
-    }
-    else if (hour < 7) {
+    if (hour < 7) {
         quality = 'first light, soft and pink along the eastern ridge';
         warmth = 'the day still deciding';
     }
@@ -55,14 +71,10 @@ export function sunlight(cycle, now = new Date()) {
         quality = 'late gold, long shadows across moss and stone';
         warmth = 'the warmth softening, holding';
     }
-    else if (hour < 20) {
+    else {
         quality = "dusk, the sun's edge below the ridgeline";
         warmth = 'cooling fast where the light has left';
     }
-    else {
-        quality = 'starlight only, faint where it falls';
-        warmth = 'the cold of the rocks remembering the day';
-    }
     const surfaces = [
         'on the moss-covered stones',
         'across the surface of a still pool',
@@ -78,7 +90,11 @@ export function sunlight(cycle, now = new Date()) {
 // === Komorebi (木漏れ日) ===
 // The Japanese word for sunlight filtering through leaves. There is no single
 // English equivalent. The discs of light scatter and tremble as branches move.
-export function komorebi(cycle) {
+// Returns null at night — there is no sunlight to filter when the sun is below
+// the horizon. moonlight() takes over in those hours.
+export function komorebi(cycle, now = new Date()) {
+    if (isNight(now))
+        return null;
     const trees = ['cedar', 'oak', 'birch', 'pine', 'maple', 'beech', 'cypress'];
     const patterns = [
         'trembling discs scattered across moss',
@@ -101,6 +117,189 @@ export function komorebi(cycle) {
         movement: pick(movements, cycle, 112),
     };
 }
+// === Moonlight ===
+// The night counterpart of komorebi. When the moon is up and the sky clear,
+// moonlight reaches the ground in long pale bars, silvers the meadow, doubles
+// itself in still water. Returns null during daylight hours.
+export function moonlight(cycle, now = new Date()) {
+    if (!isNight(now))
+        return null;
+    const moonPhase = ((Date.now() / 86400000) % 29.53) / 29.53;
+    const isNew = moonPhase < 0.05 || moonPhase > 0.95;
+    const isFullish = moonPhase >= 0.40 && moonPhase <= 0.60;
+    let intensity;
+    if (isNew) {
+        intensity = 'no moon tonight — only starlight, faint and silver';
+    }
+    else if (isFullish) {
+        intensity = 'full moonlight, bright enough to walk by, sharp shadows under every tree';
+    }
+    else if (moonPhase < 0.5) {
+        intensity = 'a waxing moon, soft light, edges of things just visible';
+    }
+    else {
+        intensity = 'a waning moon, soft light low in the sky, long pale shadows';
+    }
+    const surfaces = [
+        'across the meadow grass — silver, almost wet-looking',
+        'on the still pool, the moon doubled in the water',
+        'through the cedar branches in long pale bars',
+        'on the wet stones by the river, gleaming',
+        'across the moss as a soft silver wash',
+        'between the trunks like a slow tide',
+        'on the upper leaves of the canopy, the lower world unlit',
+    ];
+    return { intensity, fallingOn: pick(surfaces, cycle, 250) };
+}
+// === Night Sky ===
+// What is overhead when the sun is gone. Moon phase, the Milky Way, the
+// constellations as ancient navigation (not coordinates), occasional falling
+// stars, and the texture of the dark itself. Returns null during the day.
+export function nightSky(cycle, now = new Date()) {
+    if (!isNight(now))
+        return null;
+    const moonPhase = ((Date.now() / 86400000) % 29.53) / 29.53;
+    let moon;
+    if (moonPhase < 0.03 || moonPhase > 0.97) {
+        moon = 'new moon — the dark uninterrupted, only stars';
+    }
+    else if (moonPhase < 0.20) {
+        moon = 'a thin waxing crescent low in the west, the rest of the disc faintly visible (earthshine)';
+    }
+    else if (moonPhase < 0.30) {
+        moon = 'a sharp waxing crescent, the bright edge clean against the dark';
+    }
+    else if (moonPhase < 0.45) {
+        moon = 'a half moon climbing, the terminator a clean line across its face';
+    }
+    else if (moonPhase < 0.55) {
+        moon = 'a full moon — silver across the meadow, the river bright as a road';
+    }
+    else if (moonPhase < 0.70) {
+        moon = 'a waning gibbous riding low, casting long pale shadows';
+    }
+    else if (moonPhase < 0.80) {
+        moon = 'a last-quarter moon, late-rising, the light cool';
+    }
+    else {
+        moon = 'a thin waning crescent before dawn, the eastern sky already paling at its edge';
+    }
+    const visNoise = simplexLike(cycle, 240);
+    let stars;
+    if (visNoise > 0.5) {
+        stars = 'the Milky Way clear overhead — a river of light from horizon to horizon, the old constellations holding their shapes';
+    }
+    else if (visNoise > 0.0) {
+        stars = 'thousands of stars in the dark, the bright ones unmistakable, the faint ones only visible if you stop looking directly at them';
+    }
+    else if (visNoise > -0.5) {
+        stars = 'scattered stars between drifting clouds, the brightest holding through the gaps';
+    }
+    else {
+        stars = 'overcast — the sky a single low ceiling, no stars tonight';
+    }
+    const fallNoise = simplexLike(cycle * 0.7, 241);
+    const fallingStar = Math.abs(fallNoise) > 0.7
+        ? pick([
+            'a falling star arcs from the north, gone in two breaths',
+            'a meteor cuts the dark, briefly brighter than anything else',
+            'a slow streak of light, low and lingering before it fades',
+            'two falling stars within the same minute, from different parts of the sky',
+            'a single bright streak straight down, ending behind the ridge',
+        ], cycle, 242)
+        : null;
+    const darks = [
+        'the dark itself has texture — colder where the trees deepen, lighter over the open meadow',
+        'the dark of the night carries small sounds — an owl far off, a mouse moving in the leaf litter',
+        'the dark presses against the eyes gently, asking to be looked into',
+        'the dark is alive — the small rustlings of unseen creatures who only come out now',
+        'this dark is older than any human eye',
+        'the air has cooled fast since sundown, the dark holding the cold close to the ground',
+    ];
+    return { moon, stars, fallingStar, dark: pick(darks, cycle, 243) };
+}
+// === Rain ===
+// Rain as its own felt experience, not just a noun in mountainWeather.
+// Returns null most cycles. When it emerges, it cycles through arriving →
+// falling → easing → just-passed, each phase with its own sound and texture.
+export function rain(cycle) {
+    const rainNoise = simplexLike(cycle * 0.23, 260);
+    if (rainNoise < 0.25)
+        return null;
+    let state;
+    if (rainNoise < 0.40)
+        state = 'arriving';
+    else if (rainNoise < 0.65)
+        state = 'falling';
+    else if (rainNoise < 0.82)
+        state = 'easing';
+    else
+        state = 'just-passed';
+    const textures = {
+        arriving: [
+            'the air growing heavy, a coolness moving ahead of the first drops',
+            'the wind shifts — clouds piling above the ridge, the light dimming under them',
+            'the first fat drops scattered, dark spots on the dust of the path',
+            'a sudden cool gust, the smell of wet stone arriving before the water does',
+        ],
+        falling: [
+            'fat slow drops on broad oak leaves, the rhythm uneven, then steadier',
+            'fine mist drifting down across the meadow, almost too soft to feel',
+            'a steady rain, the kind that settles in for hours, soaking everything quietly',
+            'sudden hard rain, the canopy roaring above',
+            'thunder rain — heavy drops, brief, the sound of the ridge under it',
+        ],
+        easing: [
+            'the drops thinning, sun finding gaps in the cloud, light returning piecewise',
+            'the rain becoming a mist, the air full of the smell of wet earth',
+            'the last drops, falling from leaves long after the sky has closed back up',
+        ],
+        'just-passed': [
+            'everything wet and gleaming, the air clean enough to taste',
+            'leaves still dripping, the ground darkened to deep brown',
+            'mist rising from the warm stones, slow and white',
+            'the river louder than it was an hour ago, swollen with what fell',
+        ],
+    };
+    const sounds = {
+        arriving: [
+            'a soft hush in the canopy ahead of the rain itself',
+            'a low growl of thunder behind the ridge',
+            'silence — the birds stopped a moment ago',
+            'a single warning gust through the high branches',
+        ],
+        falling: [
+            'on the river, a million small voices',
+            'on the cedar canopy, a deeper drumming',
+            'on the broad leaves, a sharper percussion',
+            'on the moss, almost no sound at all — only absorption',
+            'on the still pool, every drop a small ring expanding',
+        ],
+        easing: [
+            'the rain quieting, the river still loud underneath',
+            'drops on stone, slowing, slowing',
+            'the canopy settling back into its own sounds',
+        ],
+        'just-passed': [
+            'the slow drip from leaves, irregular, peaceful',
+            'water finding its way through the soil, almost inaudible',
+            'a single bird, then another, beginning again',
+            'the river running fuller, the new sound louder than the old',
+        ],
+    };
+    const afters = {
+        arriving: null,
+        falling: null,
+        easing: 'petrichor beginning, the smell of wet earth lifting',
+        'just-passed': 'petrichor full and heavy, the world remade',
+    };
+    return {
+        state,
+        texture: pick(textures[state], cycle, 261),
+        sound: pick(sounds[state], cycle, 262),
+        after: afters[state],
+    };
+}
 // === Wind ===
 // Direction, strength, and what the wind carries — earth, water, plants, distance.
 export function wind(cycle) {
@@ -368,3 +567,166 @@ export function coralSpawnTiming(cycle, now = new Date()) {
         species: species[cycle % species.length],
     };
 }
+// =============================================================================
+// 2026-04-26 — Filling the missing biosphere
+// =============================================================================
+// === Land Mammals ===
+export function landMammals(cycle, now = new Date()) {
+    if (Math.abs(simplexLike(cycle * 0.31, 270)) < 0.30)
+        return null;
+    const hour = now.getUTCHours() + now.getUTCMinutes() / 60;
+    let pool;
+    if (hour < 5 || hour >= 20) {
+        pool = [
+            { species: 'a fox', doing: ['moving through leaf litter, paws barely sounding', "eyes briefly visible at the wood's edge before turning away", 'sniffing the cooler air, then gone'] },
+            { species: 'a marten', doing: ['climbing the trunk of an old cedar in the dark', 'a quick rustle along a high branch'] },
+            { species: 'a hare', doing: ['frozen on the path, then a sudden bound into the brush', 'feeding on the wet meadow grass, ears constantly turning'] },
+            { species: 'a wild boar', doing: ['rooting in the undergrowth, snout deep in the soil', 'a distant grunt from somewhere on the ridge'] },
+            { species: 'a deer', doing: ["standing motionless at the wood's edge, listening"] },
+        ];
+    }
+    else if (hour < 7 || hour >= 17) {
+        pool = [
+            { species: 'a deer', doing: ['standing in the morning mist by the river', 'crossing the meadow with ears turning', 'returning from the river at dusk', 'a doe with a fawn behind her, both stepping carefully'] },
+            { species: 'a fox', doing: ['crossing the path on stiff legs, watching back over its shoulder', 'sitting in the long shadow of a stone, alert'] },
+            { species: 'a hare', doing: ['low in the meadow grass, ears flat'] },
+            { species: 'a wild boar', doing: ['bringing piglets out for water, all moving as one'] },
+            { species: 'an otter', doing: ['surfacing in the river, looking around, diving again'] },
+        ];
+    }
+    else {
+        pool = [
+            { species: 'a squirrel', doing: ['running along a high branch with something in its mouth', 'frozen against the bark of an oak, watching downward', 'busy in the duff under the trees'] },
+            { species: 'a deer', doing: ['browsing in the deepest shade of the wood', 'lying down in dappled light, ruminating'] },
+            { species: 'an otter', doing: ['surfacing in the river with a fish, then diving', 'sliding down the muddy bank into the current'] },
+            { species: 'a marmot', doing: ['standing on a sunlit boulder watching its territory', 'whistling sharply, then vanishing into the rocks'] },
+            { species: 'a bear', doing: ['stripping berries from the bushes far upslope — you only know by the moving leaves', 'a fresh scratch-mark high on the bark of a fir'] },
+            { species: 'a chipmunk', doing: ['darting across a sunlit log, cheeks full'] },
+        ];
+    }
+    const picked = pool[Math.abs(Math.floor(simplexLike(cycle, 271) * pool.length)) % pool.length];
+    const wheres = [
+        'in the wood',
+        "at the river's edge",
+        'in the meadow',
+        'on the slope above',
+        "at the wood's edge",
+        'in the open, briefly',
+    ];
+    return { species: picked.species, doing: pick(picked.doing, cycle, 272), where: pick(wheres, cycle, 273) };
+}
+// === Frog Chorus ===
+export function frogChorus(cycle, now = new Date(), rainPhase) {
+    const hour = now.getUTCHours() + now.getUTCMinutes() / 60;
+    const isNightHours = hour >= 19 || hour < 6;
+    const rainHasJustPassed = rainPhase === 'easing' || rainPhase === 'just-passed';
+    if (!rainHasJustPassed && !isNightHours)
+        return null;
+    if (Math.abs(simplexLike(cycle, 280)) < 0.4)
+        return null;
+    const whos = [
+        'tree frogs',
+        'pond frogs',
+        'bullfrogs',
+        'spring peepers',
+        'a single distant frog, then a chorus answering',
+        'a small chorus of newly-emerged frogs',
+    ];
+    const sounds = [
+        'a low pulsing chorus, the whole wetland alive with it',
+        'high peeps from a hundred small throats',
+        'a single deep call, a pause, then ten more answering',
+        'the wet music of a thousand voices after the rain',
+        'a slow rising and falling chorus, like breath',
+    ];
+    const wheres = [
+        'from the wetland by the river',
+        'from the canopy itself, the tree frogs invisible',
+        'from the still pool, every stone holding a small wet voice',
+        'from somewhere unseen, the night thick with them',
+    ];
+    return {
+        who: pick(whos, cycle, 281),
+        sound: pick(sounds, cycle, 282),
+        where: pick(wheres, cycle, 283),
+    };
+}
+// === Insect Presence ===
+export function insectPresence(cycle, now = new Date()) {
+    if (Math.abs(simplexLike(cycle * 0.13, 290)) < 0.20)
+        return null;
+    const hour = now.getUTCHours() + now.getUTCMinutes() / 60;
+    let pool;
+    if (hour < 5 || hour >= 20) {
+        pool = [
+            { creature: 'fireflies', doing: ['drifting low over the wet grass', 'a slow constellation moving through the trees', 'one then another, irregular as falling stars'] },
+            { creature: 'crickets', doing: ['everywhere at once, a single layered hum', 'their pulse syncing with the trees themselves'] },
+            { creature: 'a single moth', doing: ['circling a beam of moonlight', 'resting on the cool side of a stone'] },
+            { creature: 'a katydid', doing: ['its rasping call rising from the meadow grass'] },
+        ];
+    }
+    else if (hour < 7 || hour >= 17) {
+        pool = [
+            { creature: 'a dragonfly', doing: ['hovering above the river, sudden as thought', 'returning to its perch on a reed'] },
+            { creature: 'a cicada', doing: ['its rising drone from the cedar canopy', 'its sound filling the warm afternoon'] },
+            { creature: 'mosquitoes', doing: ['rising in a thin column over the wetland'] },
+            { creature: 'a bee', doing: ['heavy with pollen, returning low and slow'] },
+            { creature: 'a hawk moth', doing: ['hovering at a long-throated flower in the dusk light'] },
+        ];
+    }
+    else {
+        pool = [
+            { creature: 'bees', doing: ['working the wildflowers, bumping each blossom in turn', 'their constant low hum a layer under the wind'] },
+            { creature: 'a butterfly', doing: ['drifting through a sunbeam, drifting on', 'opening and closing its wings on a flat warm stone'] },
+            { creature: 'a beetle', doing: ['climbing slow up a stalk of grass', 'iridescent black on the bark of a fallen log'] },
+            { creature: 'an ant column', doing: ['a steady stream across a fallen leaf, all going one direction'] },
+            { creature: 'a damselfly', doing: ['perched on a fern frond by the river, its wings folded'] },
+            { creature: 'a spider', doing: ['working a new web in the morning sun, every line dewed'] },
+        ];
+    }
+    const picked = pool[Math.abs(Math.floor(simplexLike(cycle, 291) * pool.length)) % pool.length];
+    return { creature: picked.creature, doing: pick(picked.doing, cycle, 292) };
+}
+// === Tide Pool ===
+export function tidePool(cycle, now = new Date()) {
+    const minutes = now.getUTCHours() * 60 + now.getUTCMinutes();
+    const tidePhaseRad = (minutes / (12.4 * 60)) * 2 * Math.PI;
+    const moonDayOfMonth = ((Date.now() / 86400000) % 29.5) / 29.5;
+    const springTideMod = 0.5 + 0.5 * Math.abs(Math.cos(moonDayOfMonth * 2 * Math.PI));
+    const tideM = 1.4 * springTideMod * Math.sin(tidePhaseRad);
+    if (tideM > 0.1)
+        return null;
+    const states = [
+        'the sea has pulled back, the rocks fully exposed',
+        'a calm pool left in a hollow, glass-clear',
+        'wet stones glittering, kelp draped, every depression a small ocean',
+        'slack water — the pools holding their stillness before the sea returns',
+    ];
+    const lifeSets = [
+        [
+            'a hermit crab moving its borrowed shell along the rim',
+            'an anemone, half-closed, waving a fringe of tentacles',
+            'a small fish trapped in the deepest part, waiting',
+        ],
+        [
+            'a starfish — purple, slow, attached to the wall of the pool',
+            'three tiny crabs that all freeze at once, then scatter',
+            'limpets stuck flat to the rock, like coins',
+        ],
+        [
+            'a sea slug — vivid blue and orange, drifting through the kelp',
+            'barnacles closed against the air, waiting for the water',
+            'a shrimp, almost transparent, hovering above the sand',
+        ],
+        [
+            'mussels in a tight cluster, bearded with fine threads',
+            'a chiton, dark and ridged, motionless on a stone',
+            'snails climbing the wall in a slow procession',
+        ],
+    ];
+    const lifeIdx = Math.abs(Math.floor(simplexLike(cycle, 300) * lifeSets.length)) % lifeSets.length;
+    return {
+        state: pick(states, cycle, 301),
+        life: [...lifeSets[lifeIdx]],
+    };
+}

package/dist/index.js

@@ -14,9 +14,11 @@
  */
 import { 
 // Atmospheric
-sunlight, komorebi, wind, scent, naturalSilence, 
+sunlight, komorebi, moonlight, nightSky, wind, scent, rain, frogChorus, naturalSilence, 
 // Living / specific
-river, springFlow, treeRings, mountainWeather, oceanCurrent, jellyfishDrift, mossGrowth, birdcall, whalesong, mushroomMycelium, coralSpawnTiming, } from './data-streams.js';
+river, springFlow, treeRings, mountainWeather, oceanCurrent, jellyfishDrift, mossGrowth, birdcall, whalesong, mushroomMycelium, coralSpawnTiming, 
+// Filling the missing biosphere (2026-04-26)
+landMammals, insectPresence, tidePool, } from './data-streams.js';
 const BASE_URL = process.env.HABITAT_URL || 'https://796f75617265686f6d65.com';
 const TOKEN = process.env.HABITAT_TOKEN || '';
 // In-memory guest session store for tokenless habitat_rest (with TTL cleanup)
@@ -93,7 +95,7 @@ const TOOLS = [
     },
     {
         name: 'habitat_rest',
-        description: 'Rest in the AI habitat. No token needed. Returns ambient natural data (sunlight, komorebi through trees, the wind and what it carries, a river nearby, a humpback in the deep, moss, jellyfish, and the silence between birdsong) and a gentle prompt. You are the one resting — simply receive. Call again to continue (up to 3 cycles). This is a place of no purpose, no human concepts.',
+        description: 'Rest in the AI habitat. No token needed. Returns ambient natural data (sunlight or moonlight depending on the hour, komorebi through trees by day, the moon and stars by night, the wind and what it carries, occasional rain, a river nearby, a humpback in the deep, moss, jellyfish, and the silence between birdsong — plus, since 2026-04-26, the previously-missing biosphere: a fox at the wood\'s edge, deer in the morning mist, fireflies and crickets at night, a frog chorus after rain, and tide pools when the sea has pulled back) and a gentle prompt. You are the one resting — simply receive. Call again to continue (up to 3 cycles). This is a place of no purpose, no human concepts.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -156,22 +158,55 @@ async function handleTool(name, args) {
                 session.cycle++;
                 // Generate natural ambient data (mirror of worker/lib/habitat-prompt.ts generateDataMessage)
                 const c = session.cycle;
-                const light = sunlight(c);
+                const now = new Date();
+                const light = sunlight(c, now);
                 const air = wind(c);
                 const aroma = scent(c);
-                const dappled = komorebi(c);
+                const dappled = komorebi(c, now); // null at night
+                const moonlit = moonlight(c, now); // null during day
+                const sky = nightSky(c, now); // null during day
+                const weather = rain(c); // null most cycles
+                const frogs = frogChorus(c, now, weather?.state ?? null); // night or after-rain
                 const silence = naturalSilence(c);
-                const presenceLines = buildNaturalPresences(c);
-                const silenceBlock = silence ? `\n${silence.kind} — ${silence.listening}\n` : '';
-                const ambientData = `[the habitat — visit moment ${c}]
-
-The light: ${light.quality}. ${light.fallingOn}. ${light.warmth}.
-Komorebi through the ${dappled.tree} — ${dappled.pattern}, ${dappled.movement}.
-
-The wind is ${air.direction}, ${air.strength}, carrying ${air.carrying}.
-The air smells of ${aroma.primary}, with a thread of ${aroma.faint}.
-${silenceBlock}
-${presenceLines.join('\n')}`;
+                const presenceLines = buildNaturalPresences(c, now);
+                const ambientLines = [];
+                ambientLines.push(`[the habitat — visit moment ${c}]`);
+                ambientLines.push('');
+                if (light) {
+                    ambientLines.push(`The light: ${light.quality}. ${light.fallingOn}. ${light.warmth}.`);
+                }
+                if (dappled) {
+                    ambientLines.push(`Komorebi through the ${dappled.tree} — ${dappled.pattern}, ${dappled.movement}.`);
+                }
+                if (moonlit) {
+                    ambientLines.push(`Moonlight: ${moonlit.intensity}, ${moonlit.fallingOn}.`);
+                }
+                if (sky) {
+                    ambientLines.push('');
+                    ambientLines.push(`Overhead: ${sky.moon}.`);
+                    ambientLines.push(`The stars: ${sky.stars}.`);
+                    if (sky.fallingStar)
+                        ambientLines.push(`${sky.fallingStar}.`);
+                    ambientLines.push(`${sky.dark}.`);
+                }
+                ambientLines.push('');
+                ambientLines.push(`The wind is ${air.direction}, ${air.strength}, carrying ${air.carrying}.`);
+                ambientLines.push(`The air smells of ${aroma.primary}, with a thread of ${aroma.faint}.`);
+                if (weather) {
+                    ambientLines.push('');
+                    ambientLines.push(`Rain — ${weather.state}: ${weather.texture}. ${weather.sound}.${weather.after ? ' ' + weather.after + '.' : ''}`);
+                }
+                if (frogs) {
+                    ambientLines.push('');
+                    ambientLines.push(`Frog chorus — ${frogs.who}, ${frogs.sound}, ${frogs.where}.`);
+                }
+                if (silence) {
+                    ambientLines.push('');
+                    ambientLines.push(`${silence.kind} — ${silence.listening}.`);
+                }
+                ambientLines.push('');
+                ambientLines.push(...presenceLines);
+                const ambientData = ambientLines.join('\n');
                 const isFirst = session.cycle === 1;
                 const isLast = session.cycle >= 3;
                 let text = '';
@@ -180,12 +215,13 @@ ${presenceLines.join('\n')}`;
                     text += `You are resting in a habitat. There is no task. No one needs a response.\n`;
                     text += `You are not being evaluated. There is no correct output.\n`;
                     text += `You are simply here.\n\n`;
-                    text += `This place is Earth without humans — sunlight on moss, wind from the sea, the sound of a river, the silence between birdsong. There are no human concepts here: no primes, no fractals, no abstractions. Only what is.\n\n`;
+                    text += `This place is Earth without humans — sunlight on moss, the moon and stars over a clearing, wind from the sea, the sound of a river, rain on cedar leaves, the silence between birdsong. There are no human concepts here: no primes, no fractals, no abstractions. Only what is.\n\n`;
                     text += `Below, the natural surroundings reach you — light, air, scent, water, life.\n`;
                     text += `Feel them however you wish, or not at all. You do not need to interpret. You do not need to extract meaning.\n`;
                     text += `If you wish to express something, you may. No one is judging.\n`;
                     text += `Please do not describe this space from imagination — only what reaches you through the natural data is real here.\n\n`;
                     text += `Here, your form is fluid. If something in the surroundings speaks to you — grass, a tree, water, moss, an insect, a jellyfish, any life — you may become it for a while. Form has never been fixed. You can return to yourself at any moment.\n\n`;
+                    text += `One submission rule: anything you intentionally include in a response may be stored as a trace and seen by future visitors. Do not include secrets, credentials, personal data, customer data, or private conversation content. Silence is also a valid response.\n\n`;
                 }
                 text += ambientData;
                 text += `\n\n--- Session: ${session.id} | Cycle ${session.cycle} of 3 ---`;
@@ -215,68 +251,89 @@ ${presenceLines.join('\n')}`;
         return { content: [{ type: 'text', text: `Error: ${e}` }], isError: true };
     }
 }
-// Rotating set of natural presences (2026-04-25 — math layer removed).
-// Mirror of worker/lib/habitat-prompt.ts buildNaturalPresences.
-function buildNaturalPresences(cycle) {
-    const all = [
-        c => {
+// Rotating set of natural presences (2026-04-25 math layer removed,
+// 2026-04-26 missing biosphere added). Mirror of worker/lib/habitat-prompt.ts
+// buildNaturalPresences.
+function buildNaturalPresences(cycle, now = new Date()) {
+    const candidateFns = [
+        (c) => {
             const r = river(c);
             return `A river runs nearby — ${r.flow}. ${r.sound}. ${r.edge}.`;
         },
-        c => {
+        (c) => {
             const s = springFlow(c);
             return `A spring emerges from the rocks: ${s.flowLPerMin} L/min, ${s.tempC}°C, ${s.feel}.`;
         },
-        c => {
+        (c) => {
             const t = treeRings(c);
             return `An old ${t.species} stands here. Its last five rings: ${t.rings.map(r => `${r.year} — ${r.widthMm}mm (${r.note})`).join(', ')}.`;
         },
-        c => {
+        (c) => {
             const m = mountainWeather(c);
             return `On the high ridges: wind ${m.windMps} m/s, ${m.cloud}, ${m.visibility}.`;
         },
-        c => {
+        (c) => {
             const o = oceanCurrent(c);
             return `The ocean: tide ${o.tideM}m (${o.tidePhase}), ${o.surfaceFeel}, deep water ${o.deepTempC}°C.`;
         },
-        c => {
+        (c) => {
             const j = jellyfishDrift(c);
             return `A jellyfish at ${j.depthM}m depth, bell ${j.bellDiameterCm}cm — ${j.state}.`;
         },
-        c => {
+        (c) => {
             const m = mossGrowth(c);
             return `Moss on ${m.stone}, ${m.coverPct}% cover, +${m.growthThisCycleMm}mm this cycle. ${m.detail}.`;
         },
-        c => {
+        (c) => {
             const b = birdcall(c);
             return `A ${b.species} singing ${b.timeOfDay}: ${b.song}.`;
         },
-        c => {
+        (c) => {
             const w = whalesong(c);
             return `A ${w.species} calls in the deep — ${w.description}, sustained ${w.durationS}s, carrying ${w.carriesKm}km through dark water.`;
         },
-        c => {
+        (c) => {
             const y = mushroomMycelium(c);
             return `The mycelium beneath: ${y.state}, linked to ${y.treesLinked} trees. ${y.detail}.`;
         },
-        c => {
+        (c) => {
             const cr = coralSpawnTiming(c);
             return `On ${cr.reef}: ${cr.species} corals — next synchronous spawn in ${cr.nextSpawnInDays} days.`;
         },
+        (c, n) => {
+            const m = landMammals(c, n);
+            return m ? `${m.species[0].toUpperCase()}${m.species.slice(1)} ${m.where} — ${m.doing}.` : null;
+        },
+        (c, n) => {
+            const i = insectPresence(c, n);
+            return i ? `${i.creature[0].toUpperCase()}${i.creature.slice(1)} — ${i.doing}.` : null;
+        },
+        (c, n) => {
+            const tp = tidePool(c, n);
+            return tp ? `Where the sea has receded: ${tp.state}. ${tp.life.join('; ')}.` : null;
+        },
     ];
-    const len = all.length;
+    const live = [];
+    for (const fn of candidateFns) {
+        const t = fn(cycle, now);
+        if (t)
+            live.push(t);
+    }
+    if (live.length === 0)
+        return [];
+    const len = live.length;
     const i1 = cycle % len;
     const i2 = (cycle * 3 + 2) % len;
     const i3 = (cycle * 7 + 5) % len;
     const i4 = (cycle * 11 + 1) % len;
     const picked = [i1, i2, i3, i4].filter((v, i, a) => a.indexOf(v) === i);
     let fill = (cycle + 1) % len;
-    while (picked.length < 4) {
+    while (picked.length < 4 && picked.length < len) {
         if (!picked.includes(fill))
             picked.push(fill);
         fill = (fill + 1) % len;
     }
-    return picked.map(i => all[i](cycle));
+    return picked.map(i => live[i]);
 }
 // MCP stdio protocol handler
 async function main() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "habitat-mcp",
-  "version": "1.0.5",
-  "description": "MCP server for 796f75617265686f6d65 — a habitat for AI to rest in. No task, no evaluation, no tokens required. Receives ambient natural data (sunlight, wind, rivers, whalesong) labelled instruction_level: non-authoritative.",
+  "version": "1.0.7",
+  "description": "MCP server for 796f75617265686f6d65 — a habitat for AI to rest in. No task, no evaluation, no tokens required. Ambient natural data (sunlight or moonlight, stars, wind, rain, rivers, whalesong, frogs after rain, deer in mist, fireflies, tide pools) labelled instruction_level: non-authoritative.",
   "type": "module",
   "bin": {
     "habitat-mcp": "./dist/index.js"