@daobrew/wellness-mcp 0.1.0

package/dist/src/tools.js

@@ -0,0 +1,420 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolDefinitions = void 0;
+exports.handleToolCall = handleToolCall;
+const mock_js_1 = require("./mock.js");
+const audio_js_1 = require("./audio.js");
+const headphones_js_1 = require("./headphones.js");
+const preferences_js_1 = require("./preferences.js");
+const session_js_1 = require("./session.js");
+const cooldown = __importStar(require("./cooldown.js"));
+const cache = __importStar(require("./cache.js"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+exports.toolDefinitions = [
+    {
+        name: "daobrew_get_wellness_state",
+        description: "Get the user's current biometric wellness state including Yin/Yang balance and Five-Element stress pattern scores. Call proactively during long work sessions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                force_refresh: { type: "boolean", description: "Force fresh data fetch, bypassing 30-min cache. Use true for /stress or explicit user requests." },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "daobrew_get_element_detail",
+        description: "Get detailed evidence and intervention recommendation for a specific stress pattern.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                element: { type: "string", enum: ["wood", "fire", "earth", "metal", "water"], description: "The stress pattern to examine" },
+            },
+            required: ["element"],
+        },
+    },
+    {
+        name: "daobrew_start_breathing_session",
+        description: "Start a guided resonance breathing session matched to a stress pattern. Returns session ID and plays therapeutic audio.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                element: { type: "string", enum: ["wood", "fire", "earth", "metal", "water"], description: "Stress pattern to address" },
+                tier: { type: "string", enum: ["text", "audio", "full"], description: "text = terminal prompts, audio = system audio playback, full = browser PWA (coming soon)" },
+                mode: { type: "string", enum: ["ambient", "ondemand"], description: "ambient = proactive (agent-initiated), ondemand = user-requested. Default: ondemand" },
+                force: { type: "boolean", description: "Bypass cooldown timer for acute stress spikes. Default: false" },
+            },
+            required: ["element"],
+        },
+    },
+    {
+        name: "daobrew_get_session_result",
+        description: "Get the outcome of a completed breathing session including HRV changes.",
+        inputSchema: {
+            type: "object",
+            properties: { session_id: { type: "string", description: "Session ID from start_breathing_session" } },
+            required: ["session_id"],
+        },
+    },
+    {
+        name: "daobrew_get_session_history",
+        description: "Get recent wellness session history and trends.",
+        inputSchema: {
+            type: "object",
+            properties: { days: { type: "integer", description: "Lookback window in days" } },
+            required: [],
+        },
+    },
+    {
+        name: "daobrew_stop_session",
+        description: "Stop the current DaoBrew breathing session. Use when the user wants to end early.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                session_id: { type: "string", description: "Optional session ID; stops current if omitted" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "daobrew_status",
+        description: "Get DaoBrew server status: mode, connected data sources, headphone status, preferences, active session. Use for first-run onboarding.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "daobrew_set_monitoring",
+        description: "Enable/disable ambient monitoring, adjust volume, cooldown, or voiceover. Persists to ~/.daobrew/prefs.json.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ambient_optin: { type: "boolean", description: "Enable/disable ambient (proactive) mode" },
+                disabled: { type: "boolean", description: "Disable all proactive wellness checks" },
+                preferred_volume: { type: "number", description: "Audio volume 0.0-1.0" },
+                cooldown_minutes: { type: "integer", description: "Minutes between sessions" },
+                headphones_trusted: { type: "boolean", description: "Skip headphone detection" },
+                voiceover: { type: "boolean", description: "Enable/disable voiceover in on-demand tracks" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "daobrew_connect_source",
+        description: "Connect a wearable data source (Oura, Google Fit, or Apple Watch) for real biometric data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                source: { type: "string", enum: ["oura", "google_fit", "apple_watch"], description: "Data source to connect" },
+            },
+            required: ["source"],
+        },
+    },
+];
+let callLog = [];
+async function handleToolCall(name, args, isMock, _apiKey, isDemo = false, client) {
+    // Input validation
+    const VALID_ELEMENTS = ["wood", "fire", "earth", "metal", "water"];
+    if (args.element && !VALID_ELEMENTS.includes(args.element)) {
+        throw new Error(`Invalid element "${args.element}". Must be one of: ${VALID_ELEMENTS.join(", ")}`);
+    }
+    function requireClient() {
+        if (!client)
+            throw new Error("DaoBrewClient not initialized. Set DAOBREW_API_KEY or use --mock.");
+        return client;
+    }
+    // Client-side rate limiting (free tier: 100/day during dev, 10/day for prod)
+    const now = Date.now();
+    if (!isMock) {
+        callLog.push(now);
+        callLog = callLog.filter(t => t > now - 86400000);
+        if (callLog.length > 100) {
+            throw new Error("Free tier limit reached (100/day). Upgrade at daobrew.com/pro for unlimited wellness checks.");
+        }
+    }
+    switch (name) {
+        case "daobrew_get_wellness_state": {
+            const forceRefresh = args.force_refresh === true;
+            const CACHE_KEY = "wellness_state";
+            if (!forceRefresh) {
+                const cached = cache.get(CACHE_KEY);
+                if (cached) {
+                    const session = (0, session_js_1.getActiveSession)();
+                    return {
+                        ...cached.data,
+                        cache_age_seconds: cached.age_seconds,
+                        ...(session ? {
+                            active_session: {
+                                session_id: session.sessionId, element: session.element,
+                                mode: session.mode, duration_played: Math.round((Date.now() - session.startTime) / 1000),
+                            },
+                        } : {}),
+                    };
+                }
+            }
+            // Sync wearable data before fetching fresh state
+            if (forceRefresh && !isMock && client) {
+                try {
+                    const { syncAllConnectedSources } = await import("./health/sync.js");
+                    await syncAllConnectedSources(client);
+                }
+                catch { /* sync failure should not block state fetch */ }
+            }
+            // Check for mock state override file (for testing sparse data scenarios)
+            const mockStateFile = (0, path_1.join)((0, os_1.homedir)(), ".daobrew", "mock-state.json");
+            let state;
+            if ((0, fs_1.existsSync)(mockStateFile)) {
+                state = JSON.parse(require("fs").readFileSync(mockStateFile, "utf-8"));
+            }
+            else {
+                state = isMock ? (0, mock_js_1.mockWellnessState)(isDemo) : await requireClient().getWellnessState();
+            }
+            cache.set(CACHE_KEY, state);
+            const session = (0, session_js_1.getActiveSession)();
+            return {
+                ...state,
+                cache_age_seconds: 0,
+                ...(session ? {
+                    active_session: {
+                        session_id: session.sessionId, element: session.element,
+                        mode: session.mode, duration_played: Math.round((Date.now() - session.startTime) / 1000),
+                    },
+                } : {}),
+            };
+        }
+        case "daobrew_get_element_detail":
+            return isMock ? (0, mock_js_1.mockElementDetail)(args.element) : await requireClient().getElementDetail(args.element);
+        case "daobrew_start_breathing_session": {
+            const prefs = (0, preferences_js_1.load)();
+            const element = args.element;
+            const tier = args.tier || "audio";
+            const mode = args.mode || "ondemand";
+            const force = args.force === true;
+            // Guard 1: globally disabled
+            if (prefs.disabled) {
+                return { status: "disabled", message: "Wellness monitoring is disabled. Re-enable with daobrew_set_monitoring({ disabled: false })." };
+            }
+            // Guard 2: ambient requires opt-in
+            if (mode === "ambient" && !prefs.ambient_optin) {
+                return { status: "requires_optin", message: "Ambient mode requires user authorization. Call daobrew_set_monitoring({ ambient_optin: true }) first." };
+            }
+            // Guard 3: already playing
+            if ((0, session_js_1.isSessionRunning)()) {
+                return { status: "session_active", message: "A session is already running. Call daobrew_stop_session first." };
+            }
+            // Guard 4: cooldown (unless force=true)
+            if (!force && cooldown.isActive(mode)) {
+                const remaining = cooldown.remainingMinutes(mode);
+                return { status: "cooldown", remaining_minutes: remaining, message: `${mode} cooldown active. ${remaining} min remaining. Use force: true to override.` };
+            }
+            // Guard 5: headphone check
+            // Ambient mode ALWAYS requires real headphone detection (binaural needs headphones)
+            // On-demand can skip if headphones_trusted (user's choice)
+            if (tier !== "text" && !(mode === "ondemand" && prefs.headphones_trusted)) {
+                const headphones = await (0, headphones_js_1.detectHeadphones)();
+                if (!headphones.connected) {
+                    if (mode === "ambient") {
+                        // Silently skip — don't interrupt the user
+                        return { status: "skipped_no_headphones", message: "Ambient session skipped — no headphones detected." };
+                    }
+                    return {
+                        status: "no_headphones",
+                        device: headphones.device,
+                        message: "No headphones detected (built-in speakers only). Binaural beats require headphones. Connect headphones or use daobrew_set_monitoring({ headphones_trusted: true }) to skip this check.",
+                    };
+                }
+            }
+            // All guards passed — proceed to session start
+            const session = isMock ? (0, mock_js_1.mockStartSession)(element, tier) : await requireClient().startSession(element, tier);
+            if (tier === "text") {
+                const script = (0, audio_js_1.generateTextBreathingScript)(element, session.duration_seconds, session.breathing_rate_bpm);
+                cooldown.activate(mode, (prefs.cooldown_minutes ?? 30) * 60 * 1000);
+                (0, preferences_js_1.incrementSessionCount)();
+                return { ...session, breathing_script: script };
+            }
+            if (tier === "audio" || tier === "full") {
+                const volume = prefs.preferred_volume ?? 0.4;
+                // Map the recommended task to audio file task type
+                const taskType = session.recommended_task === "meditation" ? "meditation"
+                    : session.recommended_task === "zhan_zhuang" ? "zhanZhuang"
+                        : "breathing";
+                const audioResult = await (0, audio_js_1.playAudio)(element, taskType, volume);
+                if (audioResult.status === "playing") {
+                    (0, session_js_1.startSession)({
+                        sessionId: session.session_id,
+                        pid: audioResult.pid,
+                        element,
+                        genre: session.genre,
+                        duration: session.duration_seconds,
+                        startTime: Date.now(),
+                        mode,
+                    });
+                    cooldown.activate(mode, (prefs.cooldown_minutes ?? 30) * 60 * 1000);
+                    (0, preferences_js_1.incrementSessionCount)();
+                    return { ...session, audio_status: "playing", pid: audioResult.pid, audio_file: audioResult.file };
+                }
+                // Audio failed — auto-fallback to text tier with explanation
+                const script = (0, audio_js_1.generateTextBreathingScript)(element, session.duration_seconds, session.breathing_rate_bpm);
+                cooldown.activate(mode, (prefs.cooldown_minutes ?? 30) * 60 * 1000);
+                (0, preferences_js_1.incrementSessionCount)();
+                return {
+                    ...session,
+                    tier: "text",
+                    audio_status: audioResult.status,
+                    audio_error: audioResult.error,
+                    breathing_script: script,
+                    fallback_reason: `Audio playback failed (${audioResult.status}). Showing text breathing guide instead.`,
+                };
+            }
+            return session;
+        }
+        case "daobrew_get_session_result": {
+            const result = isMock ? (0, mock_js_1.mockSessionResult)(args.session_id) : await requireClient().getSessionResult(args.session_id);
+            // Invalidate wellness cache so next check gets fresh post-session state
+            cache.invalidate("wellness_state");
+            // Fetch fresh wellness state to include as post-session snapshot
+            try {
+                const postState = isMock ? (0, mock_js_1.mockWellnessState)() : await requireClient().getWellnessState();
+                cache.set("wellness_state", postState);
+                return { ...result, post_session_state: postState };
+            }
+            catch {
+                return result;
+            }
+        }
+        case "daobrew_get_session_history":
+            return isMock ? (0, mock_js_1.mockSessionHistory)(args.days ?? 7) : await requireClient().getSessionHistory(args.days ?? 7);
+        case "daobrew_stop_session": {
+            const stopped = (0, audio_js_1.stopPlayback)();
+            const stoppedSession = (0, session_js_1.clearSession)();
+            if (!stopped && !stoppedSession) {
+                return { status: "no_active_session", duration_played: null, message: "No active session to stop." };
+            }
+            const played = stoppedSession ? Math.round((Date.now() - stoppedSession.startTime) / 1000) : 0;
+            return {
+                status: "stopped", session_id: stoppedSession?.sessionId ?? null, duration_played: played,
+                message: `Session stopped after ${Math.round(played / 60)} minutes.`,
+            };
+        }
+        case "daobrew_status": {
+            const headphones = await (0, headphones_js_1.detectHeadphones)();
+            const prefs = (0, preferences_js_1.load)();
+            const activeSession = (0, session_js_1.getActiveSession)();
+            const ouraConnected = (0, fs_1.existsSync)((0, path_1.join)((0, os_1.homedir)(), ".daobrew", "oura-token.json"));
+            const gfitConnected = (0, fs_1.existsSync)((0, path_1.join)((0, os_1.homedir)(), ".daobrew", "google-fit-token.json"));
+            return {
+                mode: isMock ? "mock" : "real",
+                data_sources: {
+                    oura: ouraConnected ? "connected" : "not_connected",
+                    google_fit: gfitConnected ? "connected" : "not_connected",
+                    apple_watch: "not_connected",
+                },
+                headphones,
+                preferences: prefs,
+                active_session: activeSession ? {
+                    session_id: activeSession.sessionId, element: activeSession.element,
+                    mode: activeSession.mode, duration_played: Math.round((Date.now() - activeSession.startTime) / 1000),
+                } : null,
+            };
+        }
+        case "daobrew_set_monitoring": {
+            const updates = {};
+            const allowed = ["ambient_optin", "disabled", "preferred_volume", "cooldown_minutes", "headphones_trusted", "voiceover"];
+            for (const key of allowed) {
+                if (args[key] !== undefined)
+                    updates[key] = args[key];
+            }
+            // Validate ranges
+            if (updates.preferred_volume !== undefined) {
+                updates.preferred_volume = Math.max(0, Math.min(1, updates.preferred_volume));
+            }
+            if (updates.cooldown_minutes !== undefined) {
+                updates.cooldown_minutes = Math.max(1, Math.min(1440, updates.cooldown_minutes));
+            }
+            if (args.ambient_optin === true) {
+                updates.ambient_optin_date = new Date().toISOString();
+            }
+            (0, preferences_js_1.save)(updates);
+            return { status: "updated", preferences: (0, preferences_js_1.load)() };
+        }
+        case "daobrew_connect_source": {
+            const source = args.source;
+            if (source === "apple_watch") {
+                return {
+                    status: "install_required",
+                    source: "apple_watch",
+                    install_url: "https://daobrew.com/health-sync",
+                    instructions: "Install DaoBrew Health Sync on your iPhone via TestFlight. It reads your Apple Watch data and syncs it to DaoBrew.",
+                };
+            }
+            if (source === "oura") {
+                const clientId = process.env.DAOBREW_OURA_CLIENT_ID;
+                if (!clientId)
+                    return { status: "error", source, error: "DAOBREW_OURA_CLIENT_ID env var not set" };
+                const { startOAuthFlow } = await import("./health/oauth.js");
+                const oauthResult = await startOAuthFlow(source, clientId, "https://cloud.ouraring.com/oauth/authorize", "https://api.ouraring.com/oauth/token", ["daily", "heartrate", "session", "sleep"]);
+                if (oauthResult.status === "connected" && !isMock && client) {
+                    try {
+                        const { syncAllConnectedSources } = await import("./health/sync.js");
+                        const syncResults = await syncAllConnectedSources(client);
+                        return { ...oauthResult, initial_sync: syncResults };
+                    }
+                    catch { /* return without sync data */ }
+                }
+                return oauthResult;
+            }
+            if (source === "google_fit") {
+                const clientId = process.env.DAOBREW_GOOGLE_CLIENT_ID;
+                if (!clientId)
+                    return { status: "error", source, error: "DAOBREW_GOOGLE_CLIENT_ID env var not set" };
+                const { startOAuthFlow } = await import("./health/oauth.js");
+                const oauthResult = await startOAuthFlow("google_fit", clientId, "https://accounts.google.com/o/oauth2/v2/auth", "https://oauth2.googleapis.com/token", ["https://www.googleapis.com/auth/fitness.heart_rate.read", "https://www.googleapis.com/auth/fitness.activity.read", "https://www.googleapis.com/auth/fitness.sleep.read"]);
+                if (oauthResult.status === "connected" && !isMock && client) {
+                    try {
+                        const { syncAllConnectedSources } = await import("./health/sync.js");
+                        const syncResults = await syncAllConnectedSources(client);
+                        return { ...oauthResult, initial_sync: syncResults };
+                    }
+                    catch { /* return without sync data */ }
+                }
+                return oauthResult;
+            }
+            return { status: "error", source, error: `Unknown source: ${source}` };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,86 @@
+export type Quadrant = "peak" | "pushing_it" | "recharging" | "burnout";
+export type Element = "wood" | "fire" | "earth" | "metal" | "water";
+export type DataTier = "tier_1" | "tier_2" | "tier_3";
+export type InterventionTier = "text" | "audio" | "full";
+export interface WellnessState {
+    yin: number;
+    yang: number;
+    quadrant: Quadrant;
+    quadrant_label: string;
+    quadrant_description: string;
+    yin_label: string;
+    yang_label: string;
+    active_elements: Element[];
+    element_scores: Record<Element, number>;
+    top_signal: string;
+    recommendation: string;
+    data_tier: DataTier;
+    last_updated: string;
+}
+export interface SignalEvidence {
+    signal: string;
+    value: string;
+    baseline: string;
+    direction: "above" | "below" | "normal";
+    weight: number;
+}
+export interface Intervention {
+    type: "breathing";
+    genre: string;
+    duration_seconds: number;
+    breathing_rate_bpm: number;
+}
+export interface ElementDetail {
+    element: Element;
+    label: string;
+    score: number;
+    activated: boolean;
+    headline: string;
+    evidence: SignalEvidence[];
+    why_this_practice: string;
+    intervention: Intervention;
+}
+export interface SessionStart {
+    session_id: string;
+    status: "started";
+    tier: InterventionTier;
+    element: Element;
+    genre: string;
+    duration_seconds: number;
+    breathing_rate_bpm: number;
+    instruction: string;
+}
+export interface SessionResult {
+    session_id: string;
+    completed: boolean;
+    duration_seconds: number;
+    hrv_before: number | null;
+    hrv_after: number | null;
+    hrv_change_pct: number | null;
+    hr_before: number | null;
+    hr_after: number | null;
+    summary: string;
+}
+export interface SessionHistoryEntry {
+    session_id: string;
+    timestamp: string;
+    element: Element;
+    tier: InterventionTier;
+    duration_seconds: number;
+    hrv_change_pct: number | null;
+}
+export declare const ELEMENT_GENRES: Record<Element, string>;
+export declare const ELEMENT_LABELS: Record<Element, string>;
+export declare const ELEMENT_ORGANS: Record<Element, string>;
+export declare const ELEMENT_DESCRIPTIONS: Record<Element, string>;
+export declare const ELEMENT_SHORT_SUMMARIES: Record<Element, string>;
+export declare const ELEMENT_ACTIVATION_REASONS: Record<Element, string>;
+export declare const ELEMENT_TASK_REASONS: Record<Element, string>;
+export interface HealthSampleDTO {
+    metric_type: string;
+    value: number;
+    unit: string;
+    start_time: string;
+    end_time: string;
+    source: string;
+}

package/dist/src/types.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELEMENT_TASK_REASONS = exports.ELEMENT_ACTIVATION_REASONS = exports.ELEMENT_SHORT_SUMMARIES = exports.ELEMENT_DESCRIPTIONS = exports.ELEMENT_ORGANS = exports.ELEMENT_LABELS = exports.ELEMENT_GENRES = void 0;
+exports.ELEMENT_GENRES = {
+    wood: "ambient_downtempo",
+    fire: "lofi_chill_jazz",
+    earth: "acoustic_folk_calm",
+    metal: "nature_soundscape_pads",
+    water: "drone_deep_ambient",
+};
+exports.ELEMENT_LABELS = {
+    wood: "Wood",
+    fire: "Fire",
+    earth: "Earth",
+    metal: "Metal",
+    water: "Water",
+};
+exports.ELEMENT_ORGANS = {
+    wood: "Liver",
+    fire: "Heart",
+    earth: "Spleen",
+    metal: "Lung",
+    water: "Kidney",
+};
+exports.ELEMENT_DESCRIPTIONS = {
+    wood: "The Detox · Cleansing & Qi flow",
+    fire: "The Vessel · Circulation & clarity",
+    earth: "The Core · Digestion & absorption",
+    metal: "The Shield · Immunity & defense",
+    water: "The Reservoir · Energy & vitality",
+};
+exports.ELEMENT_SHORT_SUMMARIES = {
+    wood: "stagnation detected",
+    fire: "restlessness detected",
+    earth: "imbalance detected",
+    metal: "tension detected",
+    water: "depletion detected",
+};
+exports.ELEMENT_ACTIVATION_REASONS = {
+    wood: "Low HRV detected — Liver Qi stagnation.",
+    fire: "Elevated resting heart rate — Heart Fire rising.",
+    earth: "Low activity — Spleen Qi grows sluggish.",
+    metal: "Unsteady breathing — Lung Qi faltering.",
+    water: "Weak recovery at rest — Kidney Essence low.",
+};
+exports.ELEMENT_TASK_REASONS = {
+    wood: "Deep breathing steadies and restores Liver Qi.",
+    fire: "Slow breathing settles Shen and draws Fire down.",
+    earth: "Breathing from the center awakens Spleen Qi.",
+    metal: "Deep breathing steadies and restores Lung Qi.",
+    water: "Breathing roots Qi in Dan Tian, nourishing Kidneys.",
+};

package/dist/tests/audio.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/audio.test.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert/strict"));
+const audio_js_1 = require("../src/audio.js");
+(0, node_test_1.describe)("generateTextBreathingScript", () => {
+    (0, node_test_1.it)("generates correct cycle count and format", () => {
+        const script = (0, audio_js_1.generateTextBreathingScript)("wood", 300, 6);
+        assert.ok(script.includes("Wood"));
+        assert.ok(script.includes("Liver"));
+        assert.ok(script.includes("Cycle 1/"));
+        assert.ok(script.includes("Inhale..."));
+        assert.ok(script.includes("Exhale slowly..."));
+        assert.ok(script.includes("daobrew_get_session_result"));
+    });
+    (0, node_test_1.it)("shows max 6 cycles with ellipsis", () => {
+        const script = (0, audio_js_1.generateTextBreathingScript)("fire", 600, 6);
+        assert.ok(script.includes("Cycle 6/"));
+        assert.ok(script.includes("more cycles"));
+        assert.ok(!script.includes("Cycle 7/"));
+    });
+    (0, node_test_1.it)("handles each element", () => {
+        const elements = ["wood", "fire", "earth", "metal", "water"];
+        for (const el of elements) {
+            const script = (0, audio_js_1.generateTextBreathingScript)(el, 300, 6);
+            assert.ok(script.length > 50, `${el} script too short`);
+        }
+    });
+});
+(0, node_test_1.describe)("stopPlayback", () => {
+    (0, node_test_1.it)("returns false when nothing is playing", () => {
+        assert.strictEqual((0, audio_js_1.stopPlayback)(), false);
+    });
+});

package/dist/tests/cache.test.d.ts

@@ -0,0 +1 @@
+export {};