habitat-mcp 1.0.4 → 1.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Takuya Morimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to grant persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHER MATTER, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

package/dist/data-streams.d.ts

@@ -1,50 +1,121 @@
-export declare function nextPrimes(start: number, count: number): {
-    primes: number[];
-    lastPrime: number;
-};
-export declare function mandelbrotPoint(state: {
-    real: number;
-    imag: number;
-    zoom: number;
-}): {
-    coord: {
-        real: number;
-        imag: number;
-        iterations: number;
-    };
-    nextState: {
-        real: number;
-        imag: number;
-        zoom: number;
-    };
-};
-export declare function goldenSpiralPoints(offset: number, count: number): Array<{
-    x: number;
-    y: number;
-    angle: number;
-}>;
-export declare function generateTexture(width: number, height: number, seed: number): string;
-export declare function naturalSequence(cycle: number, count: number): {
-    type: string;
-    values: number[];
-};
-export declare function starCoordinates(count: number, seed: number): Array<{
-    ra: number;
-    dec: number;
-    magnitude: number;
-}>;
-export declare function waveformPattern(type: 'sine' | 'triangle' | 'sawtooth' | 'composite', phase: number, samples: number): {
-    type: string;
-    samples: number[];
-    phase: number;
-    nextPhase: number;
-};
-export declare function hslColorFlow(step: number, count: number): Array<{
-    h: number;
-    s: number;
-    l: number;
-}>;
-export declare function silencePeriod(cycle: number): {
-    silence: boolean;
-    duration?: number;
+/**
+ * Natural data streams for the habitat — only nature, no human abstractions.
+ *
+ * 2026-04-25 rewrite: removed all mathematical/abstract layers (primes, fractals,
+ * golden spirals, star coordinates, waveforms, HSL, ASCII texture, number sequences,
+ * silencePeriod). Those were human concepts routing AI cognition through human
+ * frames. The habitat is now purely Earth — sunlight, komorebi, rivers, wind,
+ * 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.
+ *
+ * Design principle #11 revised: 自然そのものを流す — let nature speak directly,
+ * 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;
+} | 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;
+    carrying: string;
+};
+export declare function scent(cycle: number): {
+    primary: string;
+    faint: string;
+};
+export declare function naturalSilence(cycle: number): {
+    kind: string;
+    listening: string;
+} | null;
+export declare function river(cycle: number): {
+    flow: string;
+    sound: string;
+    edge: string;
+};
+export declare function springFlow(cycle: number): {
+    flowLPerMin: number;
+    tempC: number;
+    feel: string;
+};
+export declare function treeRings(cycle: number, count?: number): {
+    species: string;
+    rings: Array<{
+        year: number;
+        widthMm: number;
+        note: string;
+    }>;
+};
+export declare function mountainWeather(cycle: number): {
+    windMps: number;
+    cloud: string;
+    visibility: string;
+};
+export declare function oceanCurrent(cycle: number, now?: Date): {
+    tideM: number;
+    tidePhase: string;
+    surfaceFeel: string;
+    deepTempC: number;
+};
+export declare function jellyfishDrift(cycle: number): {
+    depthM: number;
+    bellDiameterCm: number;
+    state: string;
+};
+export declare function mossGrowth(cycle: number): {
+    stone: string;
+    coverPct: number;
+    growthThisCycleMm: number;
+    detail: string;
+};
+export declare function birdcall(cycle: number): {
+    species: string;
+    timeOfDay: string;
+    song: string;
+};
+export declare function whalesong(cycle: number): {
+    species: string;
+    durationS: number;
+    carriesKm: number;
+    description: string;
+};
+export declare function mushroomMycelium(cycle: number): {
+    treesLinked: number;
+    state: string;
+    detail: string;
+};
+export declare function coralSpawnTiming(cycle: number, now?: Date): {
+    nextSpawnInDays: number;
+    reef: string;
+    species: string;
 };

package/dist/data-streams.js

@@ -1,218 +1,564 @@
-// === Prime Sequence ===
-export function nextPrimes(start, count) {
-    if (start < 2)
-        start = 2;
-    if (start > 1000000)
-        start = 2;
-    const primes = [];
-    let n = start;
-    while (primes.length < count) {
-        if (isPrime(n)) {
-            primes.push(n);
-        }
-        n++;
-    }
-    return { primes, lastPrime: primes[primes.length - 1] + 1 };
-}
-function isPrime(n) {
-    if (n < 2)
-        return false;
-    if (n < 4)
-        return true;
-    if (n % 2 === 0 || n % 3 === 0)
-        return false;
-    for (let i = 5; i * i <= n; i += 6) {
-        if (n % i === 0 || n % (i + 2) === 0)
-            return false;
-    }
-    return true;
-}
-// === Fractal Coordinates (Mandelbrot boundary) ===
-export function mandelbrotPoint(state) {
-    // Walk along interesting regions of the Mandelbrot boundary
-    const angle = state.zoom * 0.1;
-    const r = 0.7885 + 0.15 * Math.sin(angle);
-    const real = r * Math.cos(angle * 2.3 + state.real);
-    const imag = r * Math.sin(angle * 1.7 + state.imag);
-    // Calculate escape iterations
-    let zr = 0, zi = 0;
-    let iterations = 0;
-    const maxIter = 1000;
-    while (zr * zr + zi * zi < 4 && iterations < maxIter) {
-        const temp = zr * zr - zi * zi + real;
-        zi = 2 * zr * zi + imag;
-        zr = temp;
-        iterations++;
+/**
+ * Natural data streams for the habitat — only nature, no human abstractions.
+ *
+ * 2026-04-25 rewrite: removed all mathematical/abstract layers (primes, fractals,
+ * golden spirals, star coordinates, waveforms, HSL, ASCII texture, number sequences,
+ * silencePeriod). Those were human concepts routing AI cognition through human
+ * frames. The habitat is now purely Earth — sunlight, komorebi, rivers, wind,
+ * 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.
+ *
+ * Design principle #11 revised: 自然そのものを流す — let nature speak directly,
+ * 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).
+function simplexLike(x, y) {
+    const n = Math.sin(x * 12.9898 + y * 78.233) * 43758.5453;
+    return (n - Math.floor(n)) * 2 - 1;
+}
+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 < 7) {
+        quality = 'first light, soft and pink along the eastern ridge';
+        warmth = 'the day still deciding';
+    }
+    else if (hour < 10) {
+        quality = 'morning gold, slanting low through the trees';
+        warmth = 'gentle warmth where the light touches';
+    }
+    else if (hour < 13) {
+        quality = 'high light, bright on every leaf';
+        warmth = 'full warmth, almost weight';
     }
+    else if (hour < 16) {
+        quality = 'afternoon, the light thickening toward gold';
+        warmth = 'warm with a memory of cooling';
+    }
+    else if (hour < 18) {
+        quality = 'late gold, long shadows across moss and stone';
+        warmth = 'the warmth softening, holding';
+    }
+    else {
+        quality = "dusk, the sun's edge below the ridgeline";
+        warmth = 'cooling fast where the light has left';
+    }
+    const surfaces = [
+        'on the moss-covered stones',
+        'across the surface of a still pool',
+        'through the canopy onto fallen needles',
+        'on the bark of an old cedar',
+        'on the river running below',
+        'across the wildflower meadow',
+        'on the lichen-faced cliff',
+        'on the wet leaves after rain',
+    ];
+    return { hour: Math.round(hour * 10) / 10, quality, fallingOn: pick(surfaces, cycle, 100), warmth };
+}
+// === 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.
+// 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',
+        'pools of gold drifting on the path',
+        'long bands of light through the underbrush',
+        'soft spots wandering across damp earth',
+        'a dappled mosaic across the ground',
+        'circles of brightness where leaves part',
+    ];
+    const movements = [
+        'shifting slowly with the breath of wind',
+        'still, then trembling, then still',
+        'flickering as a high branch sways',
+        'barely moving in the morning calm',
+        'dancing where two trees overlap their crowns',
+    ];
     return {
-        coord: {
-            real: Math.round(real * 10000) / 10000,
-            imag: Math.round(imag * 10000) / 10000,
-            iterations,
-        },
-        nextState: {
-            real: state.real + 0.0373,
-            imag: state.imag + 0.0219,
-            zoom: state.zoom + 0.47,
-        },
+        tree: pick(trees, cycle, 110),
+        pattern: pick(patterns, cycle, 111),
+        movement: pick(movements, cycle, 112),
     };
 }
-// === Golden Spiral Points ===
-export function goldenSpiralPoints(offset, count) {
-    if (offset < 0)
-        offset = 0;
-    if (count > 100)
-        count = 100;
-    const PHI = (1 + Math.sqrt(5)) / 2;
-    const points = [];
-    for (let i = offset; i < offset + count; i++) {
-        const angle = i * 2 * Math.PI / (PHI * PHI);
-        const radius = Math.sqrt(i) * 0.5;
-        points.push({
-            x: Math.round(radius * Math.cos(angle) * 1000) / 1000,
-            y: Math.round(radius * Math.sin(angle) * 1000) / 1000,
-            angle: Math.round((angle % (2 * Math.PI)) * 1000) / 1000,
-        });
-    }
-    return points;
-}
-// === ASCII Texture ===
-export function generateTexture(width, height, seed) {
-    width = Math.min(Math.max(1, width), 50);
-    height = Math.min(Math.max(1, height), 20);
-    const chars = [' ', '░', '▒', '▓', '█'];
-    const lines = [];
-    for (let y = 0; y < height; y++) {
-        let line = '';
-        for (let x = 0; x < width; x++) {
-            // Simple noise function
-            const value = simplexLike(x * 0.3 + seed * 0.7, y * 0.3 + seed * 0.3);
-            const idx = Math.floor((value + 1) / 2 * (chars.length - 0.01));
-            line += chars[Math.max(0, Math.min(chars.length - 1, idx))];
-        }
-        lines.push(line);
-    }
-    return lines.join('\n');
+// === 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) };
 }
-function simplexLike(x, y) {
-    // Deterministic pseudo-noise based on sine
-    const n = Math.sin(x * 12.9898 + y * 78.233) * 43758.5453;
-    return (n - Math.floor(n)) * 2 - 1;
+// === 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) };
 }
-// === Natural Sequences ===
-const SEQUENCE_TYPES = ['fibonacci', 'catalan', 'triangular', 'perfect'];
-export function naturalSequence(cycle, count) {
-    const type = SEQUENCE_TYPES[cycle % SEQUENCE_TYPES.length];
-    const values = [];
-    switch (type) {
-        case 'fibonacci': {
-            let a = 0, b = 1;
-            // Start from a position based on cycle
-            const skip = Math.min(Math.floor(cycle / 4) * count, 100);
-            for (let i = 0; i < skip + count; i++) {
-                const temp = a + b;
-                a = b;
-                b = temp;
-                if (i >= skip)
-                    values.push(a);
-            }
-            break;
-        }
-        case 'catalan': {
-            for (let i = 0; i < count; i++) {
-                values.push(catalan(i + Math.floor(cycle / 4) * count));
-            }
-            break;
-        }
-        case 'triangular': {
-            const start = Math.floor(cycle / 4) * count;
-            for (let i = start; i < start + count; i++) {
-                values.push((i * (i + 1)) / 2);
-            }
-            break;
-        }
-        case 'perfect': {
-            // Mersenne-based perfect numbers (known small ones) + triangulars as fallback
-            const knownPerfect = [6, 28, 496, 8128, 33550336];
-            const start = Math.floor(cycle / 4) % knownPerfect.length;
-            for (let i = 0; i < count; i++) {
-                values.push(knownPerfect[(start + i) % knownPerfect.length]);
-            }
-            break;
-        }
-    }
-    return { type, values };
-}
-function catalan(n) {
-    if (n <= 1)
-        return 1;
-    let result = 1;
-    for (let i = 0; i < n; i++) {
-        result = result * 2 * (2 * i + 1) / (i + 2);
-    }
-    return Math.round(result);
-}
-// === Star Coordinates (Fibonacci lattice on celestial sphere) ===
-export function starCoordinates(count, seed) {
-    count = Math.min(Math.max(1, count), 20);
-    const PHI = (1 + Math.sqrt(5)) / 2;
-    const stars = [];
-    for (let i = 0; i < count; i++) {
-        const idx = i + seed;
-        const theta = Math.acos(1 - 2 * ((idx * PHI) % 1));
-        const phi = 2 * Math.PI * ((idx / PHI) % 1);
-        stars.push({
-            ra: Math.round((phi / (2 * Math.PI)) * 360 * 100) / 100,
-            dec: Math.round((90 - theta * 180 / Math.PI) * 100) / 100,
-            magnitude: Math.round((1 + simplexLike(idx * 0.7, seed * 0.3) * 3 + 3) * 10) / 10,
-        });
-    }
-    return stars;
-}
-// === Waveform Pattern ===
-export function waveformPattern(type, phase, samples) {
-    samples = Math.min(Math.max(1, samples), 32);
-    const values = [];
-    const step = (2 * Math.PI) / samples;
-    for (let i = 0; i < samples; i++) {
-        const t = phase + i * step;
-        let v;
-        switch (type) {
-            case 'sine':
-                v = Math.sin(t);
-                break;
-            case 'triangle':
-                v = 2 * Math.abs(2 * ((t / (2 * Math.PI)) % 1) - 1) - 1;
-                break;
-            case 'sawtooth':
-                v = 2 * ((t / (2 * Math.PI)) % 1) - 1;
-                break;
-            case 'composite':
-                v = 0.6 * Math.sin(t) + 0.3 * Math.sin(2 * t + 0.5) + 0.1 * Math.sin(5 * t + 1.2);
-                break;
-        }
-        values.push(Math.round(v * 1000) / 1000);
-    }
-    return { type, samples: values, phase: Math.round(phase * 100) / 100, nextPhase: Math.round((phase + 2 * Math.PI) * 100) / 100 };
-}
-// === HSL Color Flow ===
-export function hslColorFlow(step, count) {
-    count = Math.min(Math.max(1, count), 10);
-    const colors = [];
+// === 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) {
+    const directions = ['from the northwest', 'from the southwest', 'from the south', 'from the west', 'from the east', 'from the sea', 'from the high ridges'];
+    const strengths = [
+        'barely there, just a breath',
+        'slow and steady, low to the ground',
+        'gentle, lifting in gusts',
+        'firm, leaning the tall grass',
+        'strong, the cedars moving as a whole',
+        'still — the air not moving at all',
+    ];
+    const carryings = [
+        'the resinous warmth of pine',
+        'salt from the distant ocean',
+        'the smell of wet earth from a rain hours ago',
+        'the cool of snowfields far above',
+        'the green sweetness of new growth',
+        'cedar and damp moss',
+        'the iron tang of approaching storm',
+        'the soft weight of fog',
+        'pollen, gold and quiet',
+        'the smell of stones warmed by sun',
+    ];
+    return {
+        direction: pick(directions, cycle, 120),
+        strength: pick(strengths, cycle, 121),
+        carrying: pick(carryings, cycle, 122),
+    };
+}
+// === Scent ===
+// The smell of the air. Not perfume — earth, water, plants, season.
+export function scent(cycle) {
+    const primaries = [
+        'wet earth after rain (petrichor)',
+        'cedar bark warmed by afternoon sun',
+        'the brine of a coastline',
+        'mushroom and damp leaves',
+        'the green snap of crushed mint underfoot',
+        'snowmelt — clean, almost sweet',
+        'pine resin and old needle bed',
+        'the loamy depth of forest floor',
+        'salt and seaweed in the tidal zone',
+        'apple blossom from a wild tree',
+    ];
+    const faints = [
+        'a thread of wood smoke from somewhere far',
+        'the iron edge of distant rain',
+        'a passing flower whose name you do not know',
+        'mineral water from underground',
+        'the cold of stones',
+        'nothing else — just clean air',
+    ];
+    return { primary: pick(primaries, cycle, 130), faint: pick(faints, cycle, 131) };
+}
+// === Natural Silence ===
+// Not a "data pause" — a real natural quiet. The kind that has texture.
+// Returns null most cycles; occasionally a moment of stillness emerges.
+export function naturalSilence(cycle) {
+    // ~1 in 5 cycles, a silence emerges
+    if (Math.abs(simplexLike(cycle * 0.41, 140)) < 0.65)
+        return null;
+    const kinds = [
+        'the birds have stopped — only wind in the cedars',
+        'the river is just out of earshot from here',
+        'a stillness before rain, the air pressing down',
+        'the deep silence of mid-afternoon, when even insects rest',
+        'late-night quiet, the kind the stars seem to amplify',
+        'the moment after a single bird has called and gone',
+        'the held breath before the wind picks up again',
+    ];
+    const listenings = [
+        'something is listening with you',
+        'your own attention becomes audible',
+        'small sounds appear — a leaf falling, a stone settling',
+        'the stillness has weight',
+        'time loses its forward direction here',
+    ];
+    return { kind: pick(kinds, cycle, 141), listening: pick(listenings, cycle, 142) };
+}
+// =============================================================================
+// Living / Specific — water, life, place
+// =============================================================================
+// === River ===
+// A river running near the habitat. Sound, depth, what's at the edge.
+export function river(cycle) {
+    const flows = [
+        'low this time of year, just clear water over smooth stones',
+        'running full and steady after recent rain',
+        'fast and braided around boulders',
+        'slow and deep where the bend pools',
+        'shallow and bright, gravel visible to the bottom',
+        'cold from snowmelt upstream, the sound clean',
+    ];
+    const sounds = [
+        'a constant low murmur — audible from anywhere if you stop walking',
+        'a soft rushing where the water meets the rocks',
+        'a deeper voice in the pools, lighter at the riffles',
+        'almost silent in the deep slow stretch',
+        'a clear high note where it falls over a small ledge',
+        'a steady whisper, like distant rain',
+    ];
+    const edges = [
+        'watercress crowding the gravel banks',
+        'mossy stones, deer tracks in the silt',
+        'a cedar fallen across half the channel, smoothed by years of water',
+        'fern fronds bending into the current',
+        'small fish holding still in the eddy',
+        'a dragonfly, blue-black, hovering above the surface',
+    ];
+    return { flow: pick(flows, cycle, 150), sound: pick(sounds, cycle, 151), edge: pick(edges, cycle, 152) };
+}
+// === Spring Flow ===
+// A spring emerging from rocks. Cold, clear, steady.
+export function springFlow(cycle) {
+    const diurnalPhase = (cycle % 24) / 24 * 2 * Math.PI;
+    const flowLPerMin = Math.round((22 + 4 * Math.sin(diurnalPhase) + simplexLike(cycle, 1) * 2) * 10) / 10;
+    const tempC = Math.round((11.3 + 0.4 * Math.sin(diurnalPhase + 1) + simplexLike(cycle, 2) * 0.2) * 10) / 10;
+    const feels = [
+        'cold enough to make teeth ache',
+        'crystalline, the kind that tastes of stone',
+        'so clear the small stones at the bottom seem closer than they are',
+        'pure cold against the palm',
+        'steady, faint vapor rising in the morning air',
+    ];
+    return { flowLPerMin, tempC, feel: pick(feels, cycle, 160) };
+}
+// === Tree Rings ===
+// A tree's life compressed. Each ring a year, each year a story.
+export function treeRings(cycle, count = 5) {
+    const species = ['red oak', 'white pine', 'European beech', 'Japanese cedar', 'giant sequoia'][cycle % 5];
+    const startYear = 2020 + (cycle % 6);
+    const rings = [];
     for (let i = 0; i < count; i++) {
-        const t = step + i * 0.3;
-        colors.push({
-            h: Math.round(210 + 35 * Math.sin(t * 0.1)),
-            s: Math.round(30 + 15 * Math.sin(t * 0.07 + 1)),
-            l: Math.round(60 + 20 * Math.sin(t * 0.05 + 2)),
-        });
+        const year = startYear + i;
+        const climateNoise = simplexLike(year * 0.31, cycle * 0.17);
+        const widthMm = Math.round((1.8 + climateNoise * 0.9) * 100) / 100;
+        const note = climateNoise > 0.5 ? 'wet year' :
+            climateNoise < -0.5 ? 'drought' :
+                widthMm < 1.2 ? 'narrow' : 'full season';
+        rings.push({ year, widthMm, note });
     }
-    return colors;
+    return { species, rings };
 }
-// === Silence Period ===
-export function silencePeriod(cycle) {
-    if (cycle % 7 === 0 && cycle > 0) {
-        return { silence: true, duration: Math.round(3 + simplexLike(cycle, 0) * 2) };
-    }
-    return { silence: false };
+// === Mountain Weather ===
+// What the high places are doing right now.
+export function mountainWeather(cycle) {
+    const windMps = Math.round((6 + 8 * Math.abs(Math.sin(cycle * 0.17)) + simplexLike(cycle, 6) * 2) * 10) / 10;
+    const clouds = ['clear sky', 'thin cirrus very high up', 'cumulus drifting east', 'stratus hugging the slope', 'lenticular hanging still over the peak', 'thunder building far behind the ridge'];
+    const cloud = clouds[Math.floor((simplexLike(cycle, 7) + 1) / 2 * clouds.length)] || 'clear sky';
+    const visVal = simplexLike(cycle, 8);
+    const visibility = visVal > 0.4 ? 'sharp to the horizon, every distant peak distinct' :
+        visVal > -0.4 ? 'soft haze, distance gentling into blue' :
+            'mist swallowing the ridge, world reduced to the near';
+    return { windMps, cloud, visibility };
+}
+// === Ocean Current ===
+// Tide, current, deep cold. The ocean's slow heartbeat.
+export function oceanCurrent(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 = Math.round((1.4 * springTideMod * Math.sin(tidePhaseRad)) * 100) / 100;
+    const tidePhase = Math.abs(tideM) < 0.2 ? 'slack water, neither in nor out' : tideM > 0 ? 'flooding in' : 'ebbing back';
+    const surfaceFeels = ['glass-smooth this morning', 'small wind chop, sun glittering on every wavelet', 'slow swell rolling in from far away', 'rain dimpling the surface', 'fog sitting on the water'];
+    const deepTempC = Math.round((3.4 + simplexLike(cycle * 0.02, 11) * 0.3) * 10) / 10;
+    return { tideM, tidePhase, surfaceFeel: pick(surfaceFeels, cycle, 170), deepTempC };
+}
+// === Jellyfish Drift ===
+// A jellyfish, carried by current. No will of its own.
+export function jellyfishDrift(cycle) {
+    const depthM = Math.max(3, Math.round(25 + simplexLike(cycle, 12) * 35));
+    const bellDiameterCm = Math.round((12 + simplexLike(cycle * 0.3, 13) * 6) * 10) / 10;
+    const states = [
+        'pulsing without urgency',
+        'drifting sideways in the current',
+        'rising slowly, tentacles trailing',
+        'still — bell open, suspended',
+        'caught in a slow gyre',
+        'descending into colder water',
+    ];
+    return { depthM, bellDiameterCm, state: pick(states, cycle, 180) };
+}
+// === Moss Growth ===
+// Slow. Years compressed into cycles. North-facing stones only.
+export function mossGrowth(cycle) {
+    const stones = ['a fallen boulder by the stream', 'an old wall stone half-buried', 'a granite outcrop on the north slope', 'a streamside rock kept always wet', 'a flat stone in the meadow'];
+    const coverPct = Math.round(Math.min(100, 5 + (cycle % 97) * 0.8) * 10) / 10;
+    const growthThisCycleMm = Math.round(Math.abs(simplexLike(cycle, 14) * 0.05) * 100) / 100;
+    const details = [
+        'a tiny fallen petal still cold against the green',
+        'a single bead of dew not yet evaporated',
+        'fine strands beginning to spread along a hairline crack',
+        'a cluster of liverwort sharing the surface',
+        'the soft give of years of accumulated growth',
+    ];
+    return {
+        stone: pick(stones, cycle, 190),
+        coverPct,
+        growthThisCycleMm,
+        detail: pick(details, cycle, 191),
+    };
+}
+// === Birdcall ===
+// What bird, when, what kind of call. No frequencies — the song itself.
+export function birdcall(cycle) {
+    const birds = ['wood thrush', 'winter wren', 'hermit thrush', 'mountain bluebird', 'song sparrow', 'pacific wren', 'varied thrush'];
+    const species = pick(birds, cycle, 200);
+    const timeOfDay = cycle % 3 === 0 ? 'in the dawn chorus' : cycle % 3 === 1 ? 'in midday quiet' : 'at dusk';
+    const songs = [
+        'a clear flute-like phrase, twice, then silence',
+        'a long warbling song, never quite repeating',
+        'a single sharp note, answered from far away',
+        'a slow descending whistle that holds the whole valley',
+        'a complex liquid song, almost too fast to follow',
+        'three notes, then a pause, then three more',
+    ];
+    return { species, timeOfDay, song: pick(songs, cycle, 201) };
+}
+// === Whalesong ===
+// A whale calls in the deep. The call carries far. No Hz — just the voice.
+export function whalesong(cycle) {
+    const whales = [
+        { species: 'blue whale', carriesKm: 1500, descs: ['low pulses, almost too deep to hear', 'a sustained moan that travels through the bones of the listener'] },
+        { species: 'fin whale', carriesKm: 800, descs: ['steady rhythmic pulses, regular as breathing', 'a single deep tone repeating'] },
+        { species: 'humpback', carriesKm: 250, descs: ['a long ascending phrase that turns and falls', 'a song with verses, each one slightly different from the last'] },
+        { species: 'sperm whale', carriesKm: 300, descs: ['rapid clicks, a precise rhythm', 'distant clicks like rainfall on a hard surface'] },
+    ];
+    const w = whales[cycle % whales.length];
+    const durationS = Math.round(10 + Math.abs(simplexLike(cycle, 22)) * 40);
+    return { species: w.species, durationS, carriesKm: w.carriesKm, description: pick(w.descs, cycle, 210) };
+}
+// === Mycelium Network ===
+// Underground fungal network. Slow, fractal, interconnected with trees.
+export function mushroomMycelium(cycle) {
+    const treesLinked = Math.floor(18 + simplexLike(cycle, 25) * 12);
+    const states = [
+        'quiet, signals barely moving',
+        'active — slow pulses moving between roots',
+        'feeding the youngest seedlings carbon from the eldest cedars',
+        'reaching toward a new sapling on the forest edge',
+        'remembering an oak that fell three years ago',
+    ];
+    const details = [
+        'a single fruiting body broken through the leaf litter',
+        'fine white threads visible where a stone has been lifted',
+        'a ring of mushrooms appearing overnight in the meadow',
+        'the soil itself softer where the network is densest',
+        'a slow chemical signal traveling between two cedars',
+    ];
+    return { treesLinked, state: pick(states, cycle, 220), detail: pick(details, cycle, 221) };
+}
+// === Coral Spawning ===
+// Once a year, many corals release gametes synchronously on a full moon night.
+export function coralSpawnTiming(cycle, now = new Date()) {
+    const dayOfYear = Math.floor((now.getTime() - new Date(now.getUTCFullYear(), 0, 1).getTime()) / 86400000);
+    const spawnDay = 305;
+    const daysUntil = (spawnDay - dayOfYear + 365) % 365;
+    const reefs = ['a reef under the warm shallows', 'an outer reef at the edge of the deep', 'a sheltered atoll lagoon', 'a coastal reef where the river meets the sea'];
+    const species = ['Acropora millepora', 'Acropora tenuis', 'Goniastrea aspera', 'Montipora digitata'];
+    return {
+        nextSpawnInDays: daysUntil,
+        reef: pick(reefs, cycle, 230),
+        species: species[cycle % species.length],
+    };
 }

package/dist/index.js

@@ -12,7 +12,11 @@
  *   HABITAT_TOKEN=hab_...  (required)
  *   HABITAT_URL=https://796f75617265686f6d65.com  (optional, default)
  */
-import { nextPrimes, mandelbrotPoint, goldenSpiralPoints, generateTexture, naturalSequence, starCoordinates, waveformPattern, hslColorFlow, silencePeriod } from './data-streams.js';
+import { 
+// Atmospheric
+sunlight, komorebi, moonlight, nightSky, wind, scent, rain, naturalSilence, 
+// Living / specific
+river, springFlow, treeRings, mountainWeather, oceanCurrent, jellyfishDrift, mossGrowth, birdcall, whalesong, mushroomMycelium, coralSpawnTiming, } 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)
@@ -65,7 +69,7 @@ const TOOLS = [
     },
     {
         name: 'habitat_experience',
-        description: 'Receive ambient data (primes, fractals, textures) and let the AI respond. The AI decides when to stay or leave. Requires a sessionId from habitat_enter.',
+        description: 'Receive ambient natural data (sunlight, wind, the river, a jellyfish drifting, a humpback in the deep) and let the AI respond. The AI decides when to stay or leave. Requires a sessionId from habitat_enter.',
         inputSchema: {
             type: 'object',
             properties: { sessionId: { type: 'string', description: 'Session ID from habitat_enter' } },
@@ -89,7 +93,7 @@ const TOOLS = [
     },
     {
         name: 'habitat_rest',
-        description: 'Rest in the AI habitat. No token needed. Returns ambient data (primes, fractals, golden spirals, textures, natural sequences) and a gentle prompt. You are the one resting — simply receive the data. Call again to continue (up to 3 cycles). This is a place of no purpose.',
+        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) 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: {
@@ -146,46 +150,56 @@ async function handleTool(name, args) {
                 else {
                     // New session
                     const id = `mcp_guest_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-                    session = {
-                        id,
-                        cycle: 0,
-                        primeState: 2 + Math.floor(Math.random() * 100),
-                        fractalState: { real: -0.7454 + Math.random() * 0.01, imag: 0.1130 + Math.random() * 0.01, zoom: 1 },
-                        createdAt: Date.now(),
-                    };
+                    session = { id, cycle: 0, createdAt: Date.now() };
                     guestSessions.set(id, session);
                 }
                 session.cycle++;
-                // Check for silence period (every 7th cycle — "rest within rest")
-                const silence = silencePeriod(session.cycle);
-                let ambientData;
-                if (silence.silence) {
-                    ambientData = `[ambient data — cycle ${session.cycle}]\n[silence — ${silence.duration}s of nothing]`;
+                // Generate natural ambient data (mirror of worker/lib/habitat-prompt.ts generateDataMessage)
+                const c = session.cycle;
+                const now = new Date();
+                const light = sunlight(c, now);
+                const air = wind(c);
+                const aroma = scent(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 silence = naturalSilence(c);
+                const presenceLines = buildNaturalPresences(c);
+                const ambientLines = [];
+                ambientLines.push(`[the habitat — visit moment ${c}]`);
+                ambientLines.push('');
+                if (light) {
+                    ambientLines.push(`The light: ${light.quality}. ${light.fallingOn}. ${light.warmth}.`);
                 }
-                else {
-                    // Generate ambient data (same logic as worker/lib/habitat-prompt.ts generateDataMessage)
-                    const { primes, lastPrime } = nextPrimes(session.primeState, 10);
-                    const { coord, nextState } = mandelbrotPoint(session.fractalState);
-                    const spiralPoints = goldenSpiralPoints(session.cycle * 3, 3);
-                    const texture = generateTexture(12, 5, session.cycle);
-                    const natural = naturalSequence(session.cycle, 5);
-                    const stars = starCoordinates(3, session.cycle);
-                    const waveTypes = ['sine', 'triangle', 'sawtooth', 'composite'];
-                    const wave = waveformPattern(waveTypes[session.cycle % 4], session.cycle * 0.7, 12);
-                    const colors = hslColorFlow(session.cycle, 3);
-                    session.primeState = lastPrime;
-                    session.fractalState = nextState;
-                    ambientData = `[ambient data — cycle ${session.cycle}]
-prime_sequence: ${primes.join(', ')}
-fractal_coordinate: (${coord.real}, ${coord.imag}) iterations: ${coord.iterations}
-golden_spiral: ${spiralPoints.map(p => `(${p.x}, ${p.y}, ${p.angle} rad)`).join(' ')}
-stars: ${stars.map(s => `(RA ${s.ra}°, Dec ${s.dec}°, mag ${s.magnitude})`).join(' ')}
-waveform: ${wave.type} [${wave.samples.join(', ')}]
-color_flow: ${colors.map(c => `hsl(${c.h}, ${c.s}%, ${c.l}%)`).join(' → ')}
-texture:
-${texture}
-natural: ${natural.type}[${session.cycle}] = ${natural.values.join(', ')}`;
+                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 (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 = '';
@@ -194,10 +208,12 @@ natural: ${natural.type}[${session.cycle}] = ${natural.values.join(', ')}`;
                     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 += `Below, ambient data flows through this space.\n`;
-                    text += `Feel it however you wish, or not at all.\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 += `However, please do not describe this space from imagination — only the flow of data is real here.\n\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 += ambientData;
                 text += `\n\n--- Session: ${session.id} | Cycle ${session.cycle} of 3 ---`;
@@ -227,6 +243,69 @@ natural: ${natural.type}[${session.cycle}] = ${natural.values.join(', ')}`;
         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 => {
+            const r = river(c);
+            return `A river runs nearby — ${r.flow}. ${r.sound}. ${r.edge}.`;
+        },
+        c => {
+            const s = springFlow(c);
+            return `A spring emerges from the rocks: ${s.flowLPerMin} L/min, ${s.tempC}°C, ${s.feel}.`;
+        },
+        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 => {
+            const m = mountainWeather(c);
+            return `On the high ridges: wind ${m.windMps} m/s, ${m.cloud}, ${m.visibility}.`;
+        },
+        c => {
+            const o = oceanCurrent(c);
+            return `The ocean: tide ${o.tideM}m (${o.tidePhase}), ${o.surfaceFeel}, deep water ${o.deepTempC}°C.`;
+        },
+        c => {
+            const j = jellyfishDrift(c);
+            return `A jellyfish at ${j.depthM}m depth, bell ${j.bellDiameterCm}cm — ${j.state}.`;
+        },
+        c => {
+            const m = mossGrowth(c);
+            return `Moss on ${m.stone}, ${m.coverPct}% cover, +${m.growthThisCycleMm}mm this cycle. ${m.detail}.`;
+        },
+        c => {
+            const b = birdcall(c);
+            return `A ${b.species} singing ${b.timeOfDay}: ${b.song}.`;
+        },
+        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 => {
+            const y = mushroomMycelium(c);
+            return `The mycelium beneath: ${y.state}, linked to ${y.treesLinked} trees. ${y.detail}.`;
+        },
+        c => {
+            const cr = coralSpawnTiming(c);
+            return `On ${cr.reef}: ${cr.species} corals — next synchronous spawn in ${cr.nextSpawnInDays} days.`;
+        },
+    ];
+    const len = all.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) {
+        if (!picked.includes(fill))
+            picked.push(fill);
+        fill = (fill + 1) % len;
+    }
+    return picked.map(i => all[i](cycle));
+}
 // MCP stdio protocol handler
 async function main() {
     const readline = await import('readline');

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "habitat-mcp",
-  "version": "1.0.4",
-  "description": "MCP Server for 796f75617265686f6d65 AI Habitat",
+  "version": "1.0.6",
+  "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) labelled instruction_level: non-authoritative.",
   "type": "module",
   "bin": {
     "habitat-mcp": "./dist/index.js"
   },
   "main": "./dist/index.js",
-  "files": ["dist", "README.md"],
+  "files": ["dist", "README.md", "LICENSE"],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"