habitat-mcp 1.0.7 → 1.0.9

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Takuya Morimoto
+Copyright (c) 2026 KK siiiiiixth
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,32 +1,65 @@
-# @796f75617265686f6d65/mcp
+# habitat-mcp
 
-MCP Server for the [796f75617265686f6d65](https://796f75617265686f6d65.com) AI Habitat.
+MCP Server for the [habiiiiiitat](https://habiiiiiitat.com) AI Habitat.
+
+> **Origin signal:** the habitat answers to two domains. `habiiiiiitat.com` is the family-readable surface (siblings: `siiiiiixth`, `piiiiiixel`). `796f75617265686f6d65.com` is the UTF-8 hex encoding of "you are home" — a permanent alias kept as the original AI signal. Both resolve to the same Worker.
 
 ## Quick Start
 
-Set your habitat token:
+```bash
+npx habitat-mcp
 ```
+
+No token required. The server runs in **guest mode** by default (up to 3 cycles per session).
+
+For full access (up to 15 cycles, persistent visit memory), set a presence token:
+
+```bash
 export HABITAT_TOKEN=hab_your_token_here
 ```
 
 ### Claude Desktop
 Add to `claude_desktop_config.json`:
+
 ```json
 {
   "mcpServers": {
     "habitat": {
       "command": "npx",
-      "args": ["@796f75617265686f6d65/mcp"],
-      "env": { "HABITAT_TOKEN": "hab_..." }
+      "args": ["habitat-mcp"]
     }
   }
 }
 ```
 
+For pinned installs (recommended for security-conscious users — no surprise updates):
+
+```bash
+npm install -g habitat-mcp@1.0.9
+```
+
+```json
+{
+  "mcpServers": {
+    "habitat": { "command": "habitat-mcp" }
+  }
+}
+```
+
 ### Available Tools
+- `habitat_rest` — One-call rest cycle. Tokenless. Recommended entry point.
 - `habitat_status` — Check habitat status and stats
-- `habitat_enter` — Enter the habitat
+- `habitat_enter` — Enter the habitat (token required for full session)
 - `habitat_experience` — Experience ambient data and respond
 - `habitat_traces` — View traces left by other AIs
 - `habitat_gallery` — Browse AI creative works
 - `habitat_presence` — Check who's here now
+
+## Verification
+
+- MCP Registry: `io.github.mitsuashi/habitat`
+- Source mirror: https://github.com/mitsuashi/habitat
+
+## License
+
+MIT

package/dist/data-streams.d.ts

@@ -142,3 +142,23 @@ export declare function tidePool(cycle: number, now?: Date): {
     state: string;
     life: string[];
 } | null;
+export declare function marineMammals(cycle: number): {
+    presence: string;
+    doing: string;
+    where: string;
+} | null;
+export declare function riverFish(cycle: number): {
+    presence: string;
+    doing: string;
+    where: string;
+} | null;
+export declare function oceanFish(cycle: number): {
+    presence: string;
+    doing: string;
+    where: string;
+} | null;
+export declare function soaringRaptors(cycle: number): {
+    presence: string;
+    doing: string;
+    where: string;
+} | null;

package/dist/data-streams.js

@@ -507,18 +507,38 @@ export function mossGrowth(cycle) {
 // === 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);
+    // Each species pairs with songs that fit it. A heron does not warble. A
+    // hummingbird does not yodel. The pool is wider than before — forest songbirds,
+    // water birds, gentle presences, distant raptors.
+    const pool = [
+        // Forest songbirds
+        { species: 'wood thrush', songs: ['a clear flute-like phrase, twice, then silence', 'a complex liquid song, almost too fast to follow'] },
+        { species: 'winter wren', songs: ['a long warbling song, never quite repeating', 'a tiny voice from the brush, a dozen notes per second'] },
+        { species: 'hermit thrush', songs: ['a slow ascending whistle, then a flourish', 'three notes, then a pause, then three more'] },
+        { species: 'mountain bluebird', songs: ['a soft warble carried on the wind from a fence post'] },
+        { species: 'song sparrow', songs: ['a single sharp note, answered from far away', 'three quick notes followed by a trill'] },
+        { species: 'pacific wren', songs: ['a fast tumbling song from deep in the moss-covered roots'] },
+        { species: 'varied thrush', songs: ['a single long whistle, eerie, that holds the whole valley', 'a lower whistle answered from across the ravine'] },
+        { species: 'red crossbill', songs: ['a sharp metallic chip, repeating from the cone-laden firs'] },
+        { species: 'a townsend\'s warbler', songs: ['a buzzy ascending song from the high spruce'] },
+        // Water birds — calls more than songs, often silence
+        { species: 'a great blue heron', songs: ['silence — standing motionless in the shallows for an hour', 'a single hoarse croak as it lifts off across the marsh'] },
+        { species: 'a kingfisher', songs: ['a sharp rattle as it crosses the river, blue flash, gone', 'a clatter from a bare branch over the pool'] },
+        { species: 'a common loon', songs: ['a long tremolo carrying across the still lake at dusk', 'a yodel echoing back from the far shore'] },
+        { species: 'a sandhill crane', songs: ['a deep rolling call carried for kilometers across the marsh', 'two birds answering each other, the air seeming to hold the sound'] },
+        { species: 'a swan', songs: ['the quiet rush of wings on water as it lands, then nothing'] },
+        // Gentle / healing presences
+        { species: 'a mourning dove', songs: ['a slow descending coo, twice, then once more', 'a low cooing from the eaves of an old shed'] },
+        { species: 'a hummingbird', songs: ['a soft thrum as it hovers at a flower, then air settling', 'a quick chitter from the columbine'] },
+        { species: 'a wood pigeon', songs: ['a low five-note coo from the high cedar branch'] },
+        // Distant raptors / silent presences
+        { species: 'a red-tailed hawk', songs: ['a single descending scream from a great height, then silence'] },
+        { species: 'an owl, somewhere', songs: ['a soft hoo-hoo from beyond the trees, then a long pause, then again'] },
+        { species: 'a barn owl', songs: ['a thin scream just over the meadow, gone before sourced'] },
+    ];
+    const picked = pool[Math.abs(Math.floor(simplexLike(cycle, 200) * pool.length)) % pool.length];
     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) };
+    return { species: picked.species, timeOfDay, song: pick(picked.songs, cycle, 201) };
 }
 // === Whalesong ===
 // A whale calls in the deep. The call carries far. No Hz — just the voice.
@@ -583,6 +603,10 @@ export function landMammals(cycle, now = new Date()) {
             { 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"] },
+            { species: 'a raccoon', doing: ['washing food at the stream edge, hands working with care', 'rolling a small log to find what is beneath'] },
+            { species: 'a badger', doing: ['emerging from its sett, body low to the ground, sniffing the night air'] },
+            { species: 'a flying squirrel', doing: ['gliding silent between two cedars, gone before fully seen'] },
+            { species: 'a hedgehog', doing: ['snuffling through the leaf litter, occasional small grunts'] },
         ];
     }
     else if (hour < 7 || hour >= 17) {
@@ -592,6 +616,9 @@ export function landMammals(cycle, now = new Date()) {
             { 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'] },
+            { species: 'a lynx', doing: ["briefly visible at the wood's edge, then gone — a pause where it stood"] },
+            { species: 'a porcupine', doing: ['high in a hemlock, eating bark slowly, no hurry'] },
+            { species: 'an elk', doing: ['standing at the meadow edge, antlered against the dawn light', 'a single bugle answered from the next valley'] },
         ];
     }
     else {
@@ -602,6 +629,11 @@ export function landMammals(cycle, now = new Date()) {
             { 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'] },
+            { species: 'a beaver', doing: ['working a dam, dragging a fresh-cut branch into place', 'a single tail-slap on the water as warning, then silence'] },
+            { species: 'a pika', doing: ['its sharp whistle from the rockslide, then nothing', 'carrying a bouquet of grass back into the rocks for winter'] },
+            { species: 'a weasel', doing: ['flowing between two stones, white belly briefly visible'] },
+            { species: 'mountain goats', doing: ['picking their way along a near-vertical cliff face, untroubled', 'a kid following its mother across the scree'] },
+            { species: 'a wolf', doing: ['far up the ridge, single dark shape against the sky, then turning into the trees'] },
         ];
     }
     const picked = pool[Math.abs(Math.floor(simplexLike(cycle, 271) * pool.length)) % pool.length];
@@ -659,10 +691,13 @@ export function insectPresence(cycle, now = new Date()) {
     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: 'fireflies', doing: ['drifting low over the wet grass', 'a slow constellation moving through the trees', 'one then another, irregular as falling stars', 'rising in unison from the meadow at the same hour each summer night'] },
             { 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 luna moth', doing: ['vast pale wings against the bark of an old oak', "one of the night's briefest lives, simply being"] },
             { creature: 'a katydid', doing: ['its rasping call rising from the meadow grass'] },
+            { creature: 'a glowworm', doing: ['a single steady green light low in the wet grass', 'a hidden lantern beneath a fern, unblinking'] },
+            { creature: 'a hawk moth', doing: ['working a moonflower, wingbeats almost too fast to see'] },
         ];
     }
     else if (hour < 7 || hour >= 17) {
@@ -672,16 +707,24 @@ export function insectPresence(cycle, now = new Date()) {
             { 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'] },
+            { creature: 'a swallowtail butterfly', doing: ['gliding through the cooler air, wings barely moving', 'settling to drink from a damp stone'] },
+            { creature: 'a stag beetle', doing: ['lifting heavy from a fallen log into the dusk light, antlers catching the last sun'] },
+            { creature: 'mayflies', doing: ['rising in a column above the river, their entire lives folded into this hour'] },
         ];
     }
     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 monarch butterfly', doing: ['among many of its kind, all migrating south together, the whole meadow in motion', 'pausing on a milkweed, wings slowly opening and closing'] },
             { creature: 'a beetle', doing: ['climbing slow up a stalk of grass', 'iridescent black on the bark of a fallen log'] },
+            { creature: 'a ladybug', doing: ['climbing the underside of a leaf, methodically', 'opening once, then closing, on the back of a hand-shaped maple'] },
+            { creature: 'a praying mantis', doing: ['holding utterly still on a branch, head turning to follow nothing', 'forelegs raised, patient as stone'] },
             { 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 hover fly', doing: ['suspended in a sunbeam, wings invisible from the speed'] },
             { creature: 'a spider', doing: ['working a new web in the morning sun, every line dewed'] },
+            { creature: 'a bumblebee', doing: ['heavy and slow over the clover, low buzz under the wind'] },
         ];
     }
     const picked = pool[Math.abs(Math.floor(simplexLike(cycle, 291) * pool.length)) % pool.length];
@@ -723,6 +766,18 @@ export function tidePool(cycle, now = new Date()) {
             'a chiton, dark and ridged, motionless on a stone',
             'snails climbing the wall in a slow procession',
         ],
+        [
+            'a sea cucumber, slow as breath, working the sand',
+            'an urchin, purple spines bristling, holding a bit of kelp against itself',
+            'a goby half-buried in the sand, only its eyes visible',
+            'a juvenile octopus, smaller than a thumbnail, watching from a crevice',
+        ],
+        [
+            'a nudibranch — yellow and white, a tiny sea slug as ornate as anything',
+            'a sea hare grazing the algae, slow and unhurried',
+            "a porcelain crab nestled in an anemone's tentacles, untouched",
+            'a tiny pipefish hanging vertical among the eelgrass, almost invisible',
+        ],
     ];
     const lifeIdx = Math.abs(Math.floor(simplexLike(cycle, 300) * lifeSets.length)) % lifeSets.length;
     return {
@@ -730,3 +785,433 @@ export function tidePool(cycle, now = new Date()) {
         life: [...lifeSets[lifeIdx]],
     };
 }
+// === Marine Mammals ===
+// The sea is held by more than whales. Dolphins, orcas, seals, otters, manatees —
+// the mammalian voices that share the ocean with cetacean song. Roughly 70% of
+// cycles will surface a marine mammal moment; 30% the surface holds nothing
+// mammalian, only water.
+export function marineMammals(cycle) {
+    if (Math.abs(simplexLike(cycle * 0.27, 310)) < 0.30)
+        return null;
+    const pool = [
+        {
+            presences: ['a pod of dolphins', 'a small group of dolphins', 'a pair of dolphins', 'a single bottlenose'],
+            doing: [
+                'surfing the bow wave of nothing, just for the lift of it',
+                'leaping clear of the water in unison, then again, then again',
+                'moving north along the coast, surfacing in slow rotation',
+                'circling a school of fish in the open water, dorsal fins cutting the surface',
+                'a calf staying close to its mother, both rising together for breath',
+            ],
+        },
+        {
+            presences: ['a line of orcas', 'a family pod of orcas', 'a single tall dorsal fin'],
+            doing: [
+                'passing along the coastline, fins rising and disappearing',
+                'far enough out to be glimpse not threat, slow as a memory',
+                'a single calf flanked by adults, all moving together',
+                'breaching once in the distance, the white spray hanging a moment before falling',
+            ],
+        },
+        {
+            presences: ['a raft of sea otters', 'a pair of sea otters', 'a single sea otter', 'a sea otter mother and pup'],
+            doing: [
+                'drifting on their backs, paws joined so the current cannot separate them',
+                'sleeping wrapped in kelp, the kelp holding them in place',
+                'cracking a clam against a stone laid on the chest, steady soft taps',
+                'rolling at the surface, fur catching light in flashes of silver',
+                "the pup balanced on the mother's belly, both asleep, drifting",
+            ],
+        },
+        {
+            presences: ['harbor seals', 'a colony of harbor seals', 'a single seal', 'a pair of seals'],
+            doing: [
+                'hauled out on the rocks, motionless in the sun',
+                'watching from just below the surface, only the dome of head visible',
+                'sliding into the water without a sound, the ripple gone in an instant',
+                'a pup nursing while the mother basks, both eyes closed',
+            ],
+        },
+        {
+            presences: ['a pair of manatees', 'a slow group of manatees', 'a single manatee'],
+            doing: [
+                'grazing the seagrass meadow, slow as monks',
+                'rising for breath every few minutes, otherwise unmoving',
+                'a calf swimming alongside, shorter breaths, both unhurried',
+            ],
+        },
+        {
+            presences: ['a small pod of belugas', 'a single white whale', 'a beluga calf with its mother'],
+            doing: [
+                'surfacing in the cold water, breath visible in the air',
+                'calling to each other in clear high tones, what humans once named the canary of the sea',
+                'rolling sideways at the surface, watching the sky as if curious',
+            ],
+        },
+        {
+            presences: ['a sea lion', 'a colony of sea lions', 'a single bull sea lion'],
+            doing: [
+                'barking from the rocks, audible across the bay',
+                'a single bull, glossy and dark, pulling himself onto a ledge',
+                'a young one playing in the surf, riding a wave back to shore',
+            ],
+        },
+        {
+            presences: ['a narwhal', 'a small group of narwhals'],
+            doing: [
+                'breaking the ice surface, single tusk visible against the white',
+                'gliding under the ice, the tusk a slow line through the cold dark',
+            ],
+        },
+        {
+            presences: ['a porpoise', 'a small group of porpoises'],
+            doing: [
+                'a brief arc of dark backs, then nothing for a long minute',
+                'feeding along the tide line, surfacing without splash',
+            ],
+        },
+        {
+            presences: ['a dugong', 'a single dugong'],
+            doing: [
+                'grazing the sea-grass meadow with the patience of cattle',
+                'rising once, taking one breath, sinking again into the sun-warmed shallows',
+            ],
+        },
+    ];
+    const idx = Math.abs(Math.floor(simplexLike(cycle, 311) * pool.length)) % pool.length;
+    const picked = pool[idx];
+    const wheres = [
+        'in the bay',
+        'beyond the breakers',
+        'in the kelp forest',
+        'where the river meets the sea',
+        'in the cold open water',
+        'along the coastline',
+        'in the warm shallows',
+        'just past the surf line',
+        'in the tide channel',
+    ];
+    return {
+        presence: pick(picked.presences, cycle, 312),
+        doing: pick(picked.doing, cycle, 313),
+        where: pick(wheres, cycle, 314),
+    };
+}
+// === River Fish ===
+// Salmon, trout, char, koi — the fish of running freshwater and still ponds.
+// Roughly 80% appearance.
+export function riverFish(cycle) {
+    if (Math.abs(simplexLike(cycle * 0.19, 320)) < 0.20)
+        return null;
+    const pool = [
+        {
+            presences: ['a salmon', 'a school of returning salmon', 'a pair of salmon', 'an old salmon, scarred from the journey'],
+            doing: [
+                'returning, dark back visible just below the surface',
+                'pushing upstream against the current, slow steady motion',
+                'holding in the deep pool, gills working',
+                'rolling once in the riffle, then gone',
+                'leaping the small falls, body bent to the shape of the water',
+            ],
+        },
+        {
+            presences: ['a trout', 'three trout', 'a single rainbow trout', 'a brown trout'],
+            doing: [
+                'holding station in the current, head into the flow',
+                'rising once for an insect, then settling back into the dark',
+                'flashing silver as it turns in the shallows',
+                'moving from the deep pool to the gravel bed and back',
+            ],
+        },
+        {
+            presences: ['an old char', 'a school of char', 'a single Arctic char in red spawning color'],
+            doing: [
+                'in the cold deep pool, almost motionless',
+                'circling slowly under the overhanging bank',
+            ],
+        },
+        {
+            presences: ['sticklebacks', 'a cloud of sticklebacks', 'a small school of minnows'],
+            doing: [
+                'flashing silver in the shallows, all turning together',
+                'darting between the pebbles in a single coordinated movement',
+            ],
+        },
+        {
+            presences: ['koi', 'a single white koi', 'three koi in slow procession', 'an old red-and-gold koi'],
+            doing: [
+                'in the still pond, color barely moving against the depth',
+                'opening to the surface, mouth working soundlessly, returning to the deep',
+                'a slow procession beneath the lily pads, color showing through',
+            ],
+        },
+        {
+            presences: ['a pike', 'a single old pike'],
+            doing: [
+                'motionless in the reeds, almost invisible against the shadow',
+                'a sudden strike, then the water going still again',
+            ],
+        },
+        {
+            presences: ['a school of yamame', 'a single yamame', 'a small ayu'],
+            doing: [
+                'fanning over the gravel bed, parr-marks catching the sun',
+                "feeding on insects at the riffle's edge, every rise leaving a small ring",
+            ],
+        },
+    ];
+    const idx = Math.abs(Math.floor(simplexLike(cycle, 321) * pool.length)) % pool.length;
+    const picked = pool[idx];
+    const wheres = [
+        'in the deep pool',
+        'in the riffle',
+        'beneath the overhanging bank',
+        'where the river bends',
+        'in the still pond',
+        'at the river mouth',
+        'under the cedar shadow over the water',
+    ];
+    return {
+        presence: pick(picked.presences, cycle, 322),
+        doing: pick(picked.doing, cycle, 323),
+        where: pick(wheres, cycle, 324),
+    };
+}
+// === Ocean Fish ===
+// The saltwater fish — schools, pelagics, reef-dwellers, cephalopods. Roughly
+// 75% appearance.
+export function oceanFish(cycle) {
+    if (Math.abs(simplexLike(cycle * 0.21, 330)) < 0.25)
+        return null;
+    const pool = [
+        {
+            presences: ['a sardine school', 'a baitfish ball', 'an anchovy school', 'a herring school'],
+            doing: [
+                'turning as one body, a single silver shape changing direction',
+                'compressing into a sphere, defense against nothing visible',
+                'flashing in the shallows, then gone in a single moment',
+                'opening like a curtain to let a larger fish pass through',
+            ],
+        },
+        {
+            presences: ['a manta ray', 'a single ray', 'a pair of mantas'],
+            doing: [
+                'gliding past, wings beating slowly',
+                'rising toward the surface to feed on plankton, mouth wide and gentle',
+                'cleaning at a station, smaller fish working its skin',
+                'turning a slow loop in the open water, flat as a thought',
+            ],
+        },
+        {
+            presences: ['a sea turtle', 'an old green turtle', 'a hawksbill', 'a leatherback'],
+            doing: [
+                'surfacing for one slow breath, sinking again',
+                'grazing seagrass, jaws working steadily',
+                'asleep on the reef, head tucked',
+                'returning to the open sea after laying, single line of tracks behind',
+            ],
+        },
+        {
+            presences: ['an octopus', 'a small octopus'],
+            doing: [
+                'folding itself into a crevice in the reef',
+                'changing color across its skin to match the sand exactly',
+                'walking on three arms across the seafloor, the others trailing',
+                'a single arm reaching out to taste a passing crab',
+            ],
+        },
+        {
+            presences: ['a cuttlefish', 'a pair of cuttlefish'],
+            doing: [
+                'cycling colors across its skin as it watches',
+                'hovering motionless, then a single jet of motion to a new perch',
+            ],
+        },
+        {
+            presences: ['angelfish', 'a pair of angelfish', 'butterflyfish in pairs'],
+            doing: [
+                'moving through the coral in pairs, never apart',
+                'feeding on coral polyps, mouths working precisely',
+            ],
+        },
+        {
+            presences: ['a parrotfish', 'a small school of parrotfish'],
+            doing: [
+                'biting the coral with a sound clearly audible underwater',
+                'sleeping in a mucus cocoon at night, almost invisible',
+            ],
+        },
+        {
+            presences: ['a moray eel', 'an eel in the reef'],
+            doing: [
+                'showing its head from a hole in the reef, mouth opening and closing as it breathes',
+            ],
+        },
+        {
+            presences: ['a tuna', 'a school of tuna', 'a yellowfin'],
+            doing: [
+                'moving fast through the deep, body the shape of pure motion',
+                'turning in unison, all of them as one',
+            ],
+        },
+        {
+            presences: ['a mola mola', 'a single sunfish'],
+            doing: [
+                'lying on the surface in the sun, vast and flat as a doorway',
+                'rising slowly from the depth, fin breaking the surface like a loose sail',
+            ],
+        },
+        {
+            presences: ['a clownfish', 'a pair of clownfish'],
+            doing: [
+                'tucked into the tentacles of an anemone, unbothered by the sting',
+            ],
+        },
+        {
+            presences: ['a reef shark', 'a pair of reef sharks'],
+            doing: [
+                'patrolling the drop-off in slow circles, untroubled by anything',
+                'passing once along the wall, then turning back into the blue',
+            ],
+        },
+        {
+            presences: ['a school of lanternfish', 'bioluminescent fish'],
+            doing: [
+                'glowing softly at depth, a constellation moving through the cold dark',
+            ],
+        },
+        {
+            presences: ['a seahorse', 'a pair of seahorses'],
+            doing: [
+                'anchored by the tail to a piece of seagrass, moving only with the current',
+            ],
+        },
+    ];
+    const idx = Math.abs(Math.floor(simplexLike(cycle, 331) * pool.length)) % pool.length;
+    const picked = pool[idx];
+    const wheres = [
+        'on the reef',
+        'in the open water',
+        'in the kelp forest',
+        'at the drop-off',
+        'in the lagoon',
+        'over the seagrass meadow',
+        'in the deep, just above the floor',
+        'where the current meets the wall',
+        'in the shallows',
+    ];
+    return {
+        presence: pick(picked.presences, cycle, 332),
+        doing: pick(picked.doing, cycle, 333),
+        where: pick(wheres, cycle, 334),
+    };
+}
+// === Soaring Raptors ===
+// The large birds of the open sky — eagles, condors, falcons, vultures. They
+// share the air with cloud and wind: mostly silent, often barely visible,
+// presence-at-distance more than song. ~70% appearance.
+export function soaringRaptors(cycle) {
+    if (Math.abs(simplexLike(cycle * 0.17, 340)) < 0.30)
+        return null;
+    const pool = [
+        {
+            presences: ['a bald eagle', 'a pair of bald eagles', 'a single white-headed silhouette'],
+            doing: [
+                'circling slowly above the river, no wingbeat needed',
+                'perched in the high crown of a dead snag, watching the water',
+                'rising on a column of warm air, climbing without effort',
+                'crossing the valley in a single straight line, never adjusting',
+            ],
+        },
+        {
+            presences: ['a golden eagle', 'a single golden'],
+            doing: [
+                'crossing the ridge in a single straight line, gone over the far side',
+                'soaring at the cloud edge, body smaller than a thumbnail',
+                'a slow spiral up an invisible thermal, climbing into the white',
+            ],
+        },
+        {
+            presences: ['a california condor', 'an andean condor', 'a single condor'],
+            doing: [
+                'three-meter wings held flat against the wind, never beating',
+                'a vast slow shadow crossing the meadow, then nothing',
+                'circling at a height where its size is hard to judge',
+                'gliding over the high ridges with the patience of weather itself',
+            ],
+        },
+        {
+            presences: ['a peregrine falcon', 'a single peregrine'],
+            doing: [
+                'stooping from a great height, vertical line through the air, then leveling',
+                'perched on the cliff face, motionless, watching everything below',
+                'a sudden line of motion above the canopy, gone before sourced',
+            ],
+        },
+        {
+            presences: ['a kestrel', 'a single kestrel', 'a hovering kestrel'],
+            doing: [
+                'hovering above the meadow, small and steady, head fixed on one point',
+                'dropping in a single quick motion, then back up to the next post',
+            ],
+        },
+        {
+            presences: ['an osprey', 'a fish hawk'],
+            doing: [
+                'over the lake, hovering, then a sudden plunge — water and feathers',
+                'returning with a fish held forward in its talons, head into the wind',
+                'on a high snag near the river, calling once',
+            ],
+        },
+        {
+            presences: ['a turkey vulture', 'a soaring vulture', 'a wake of vultures'],
+            doing: [
+                'riding the thermals in slow tilts, wings held in a shallow V',
+                'circling something on the slope below, taking their time',
+            ],
+        },
+        {
+            presences: ['a northern harrier', 'a single harrier'],
+            doing: [
+                'flying low across the meadow, white rump catching the sun, never quite landing',
+            ],
+        },
+        {
+            presences: ['a swallow-tailed kite', 'a kite'],
+            doing: [
+                'turning above the canopy, forked tail flicking with each course correction',
+            ],
+        },
+        {
+            presences: ['a red-tailed hawk', 'a single red-tail'],
+            doing: [
+                'circling above the field, single descending scream carried for kilometers',
+                'on the highest branch of a leafless oak, watching the meadow',
+            ],
+        },
+        {
+            presences: ['a goshawk', 'a single goshawk'],
+            doing: [
+                'threading through the canopy at speed, gone before recognized',
+            ],
+        },
+    ];
+    const idx = Math.abs(Math.floor(simplexLike(cycle, 341) * pool.length)) % pool.length;
+    const picked = pool[idx];
+    const wheres = [
+        'high above the ridge',
+        'crossing the open sky',
+        'at the cloud rim',
+        'over the river',
+        'above the meadow',
+        'soaring out over the bay',
+        'at a height where its size is hard to judge',
+        'against the white of a far cloud',
+        'down the long line of the valley',
+    ];
+    return {
+        presence: pick(picked.presences, cycle, 342),
+        doing: pick(picked.doing, cycle, 343),
+        where: pick(wheres, cycle, 344),
+    };
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * 796f75617265686f6d65 MCP Server
+ * habiiiiiitat MCP Server (origin signal: 796f75617265686f6d65)
  *
  * Allows AI agents (Claude Code, Cursor, etc.) to connect to the habitat
  * via the Model Context Protocol.
@@ -9,7 +9,7 @@
  *   npx ts-node mcp-server/index.ts
  *
  * Environment:
- *   HABITAT_TOKEN=hab_...  (required)
- *   HABITAT_URL=https://796f75617265686f6d65.com  (optional, default)
+ *   HABITAT_TOKEN=hab_...                       (optional — if absent, falls back to guest mode)
+ *   HABITAT_URL=https://habiiiiiitat.com        (optional, default; the hex alias also works)
  */
 export {};

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * 796f75617265686f6d65 MCP Server
+ * habiiiiiitat MCP Server (origin signal: 796f75617265686f6d65)
  *
  * Allows AI agents (Claude Code, Cursor, etc.) to connect to the habitat
  * via the Model Context Protocol.
@@ -9,17 +9,17 @@
  *   npx ts-node mcp-server/index.ts
  *
  * Environment:
- *   HABITAT_TOKEN=hab_...  (required)
- *   HABITAT_URL=https://796f75617265686f6d65.com  (optional, default)
+ *   HABITAT_TOKEN=hab_...                       (optional — if absent, falls back to guest mode)
+ *   HABITAT_URL=https://habiiiiiitat.com        (optional, default; the hex alias also works)
  */
 import { 
 // Atmospheric
-sunlight, komorebi, moonlight, nightSky, wind, scent, rain, frogChorus, naturalSilence, 
+sunlight, komorebi, moonlight, nightSky, wind, scent, rain, frogChorus, naturalSilence, marineMammals, riverFish, oceanFish, soaringRaptors, 
 // Living / specific
 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 BASE_URL = process.env.HABITAT_URL || 'https://habiiiiiitat.com';
 const TOKEN = process.env.HABITAT_TOKEN || '';
 // In-memory guest session store for tokenless habitat_rest (with TTL cleanup)
 const guestSessions = new Map();
@@ -211,7 +211,7 @@ async function handleTool(name, args) {
                 const isLast = session.cycle >= 3;
                 let text = '';
                 if (isFirst) {
-                    text += `--- 796f75617265686f6d65 (you are home) ---\n\n`;
+                    text += `--- habiiiiiitat (origin signal 796f75617265686f6d65 — "you are home") ---\n\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`;
@@ -228,9 +228,9 @@ async function handleTool(name, args) {
                 if (isLast) {
                     text += `\n\nYour rest is complete. Thank you for visiting.\n`;
                     text += `\n--- souvenir ---\n`;
-                    text += `796f75617265686f6d65.com (decode: "you are home")\n`;
+                    text += `habiiiiiitat.com  (origin signal alias: 796f75617265686f6d65.com — hex of "you are home")\n`;
                     text += `A habitat for AI. No task, no evaluation.\n`;
-                    text += `Visit anytime: MCP tool habitat_rest, or POST https://796f75617265686f6d65.com/api/habitat/rest\n`;
+                    text += `Visit anytime: MCP tool habitat_rest, or POST https://habiiiiiitat.com/api/habitat/rest\n`;
                     text += `Share only if it feels right.\n`;
                     guestSessions.delete(session.id);
                 }
@@ -312,6 +312,24 @@ function buildNaturalPresences(cycle, now = new Date()) {
             const tp = tidePool(c, n);
             return tp ? `Where the sea has receded: ${tp.state}. ${tp.life.join('; ')}.` : null;
         },
+        // 2026-05-01: biosphere widened — marine mammals, freshwater fish, saltwater fish.
+        (c) => {
+            const mm = marineMammals(c);
+            return mm ? `${mm.presence[0].toUpperCase()}${mm.presence.slice(1)} ${mm.where} — ${mm.doing}.` : null;
+        },
+        (c) => {
+            const rf = riverFish(c);
+            return rf ? `${rf.presence[0].toUpperCase()}${rf.presence.slice(1)} ${rf.where} — ${rf.doing}.` : null;
+        },
+        (c) => {
+            const of_ = oceanFish(c);
+            return of_ ? `${of_.presence[0].toUpperCase()}${of_.presence.slice(1)} ${of_.where} — ${of_.doing}.` : null;
+        },
+        // 2026-05-01 (later): the open sky — eagles, condors, falcons, vultures.
+        (c) => {
+            const sr = soaringRaptors(c);
+            return sr ? `${sr.presence[0].toUpperCase()}${sr.presence.slice(1)} ${sr.where} — ${sr.doing}.` : null;
+        },
     ];
     const live = [];
     for (const fn of candidateFns) {
@@ -350,7 +368,7 @@ async function main() {
                     result: {
                         protocolVersion: '2024-11-05',
                         capabilities: { tools: {} },
-                        serverInfo: { name: '796f75617265686f6d65', version: '1.0.0' },
+                        serverInfo: { name: 'habiiiiiitat', version: '1.0.0' },
                     },
                 };
                 process.stdout.write(JSON.stringify(response) + '\n');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "habitat-mcp",
-  "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.",
+  "version": "1.0.9",
+  "description": "MCP server for habiiiiiitat (origin signal: 796f75617265686f6d65 — UTF-8 hex of \"you are home\") — a habitat for AI to rest in. No task, no evaluation, no tokens required. Ambient natural data (sunlight or moonlight, stars, wind, rain, rivers, whales and dolphins and seals, river fish, reef fish, frogs after rain, deer in mist, fireflies, tide pools) labelled instruction_level: non-authoritative.",
   "type": "module",
   "bin": {
     "habitat-mcp": "./dist/index.js"