@cullumco/cadence 0.1.4 → 0.1.6

package/dist/cli.js

@@ -3,55 +3,77 @@ import { writeFile, mkdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { getMusicSignal } from "./providers/music.js";
-import { getSelfReportSignal } from "./providers/selfreport.js";
-import { getAmbientSignal } from "./providers/ambient.js";
+import { getSelfReportSignal, STALE_AFTER_MS } from "./providers/selfreport.js";
+import { getEnvironmentSignal } from "./providers/environment.js";
 import { getGitSignal } from "./providers/git.js";
+import { getEsotericSignal } from "./providers/esoteric.js";
 import { deriveCadence, buildReframe, loadOverrides, applyOverrides, resolveDialLevel, DIALS, DIAL_WORDS, } from "./cadence.js";
 import { render } from "./inject.js";
 import { renderSignalsTable } from "./signals-view.js";
+import { loadProviders, providerEnabled, isPaused, OPT_IN_PROVIDERS } from "./config.js";
+import { connectSpotify, REDIRECT_URI } from "./spotify-auth.js";
 const CADENCE_DIR = join(homedir(), ".cadence");
 const STATE_FILE = join(CADENCE_DIR, "state.txt");
 const CONFIG_FILE = join(CADENCE_DIR, "config.json");
-async function cmdState(args) {
+async function cmdReport(args) {
     if (args.length === 0) {
+        // Same TTL the hook applies — printing an expired report as if it were
+        // live would contradict what actually gets injected.
+        const report = await getSelfReportSignal();
+        if (report) {
+            const rem = Math.max(0, STALE_AFTER_MS - (Date.now() - report.setAt));
+            const h = Math.floor(rem / 3_600_000);
+            const m = Math.floor((rem % 3_600_000) / 60_000);
+            console.log(`${report.text}  (${h > 0 ? `${h}h${String(m).padStart(2, "0")}m` : `${m}m`} left)`);
+            return;
+        }
         try {
-            const text = (await readFile(STATE_FILE, "utf-8")).trim();
-            console.log(text || "(no state set)");
+            const stale = (await readFile(STATE_FILE, "utf-8")).trim();
+            console.log(stale
+                ? `(last self-report expired — refresh: cadence report "...")`
+                : "(no self-report set)");
         }
         catch {
-            console.log("(no state set)");
+            console.log("(no self-report set)");
         }
         return;
     }
     const text = args.join(" ");
     await mkdir(CADENCE_DIR, { recursive: true });
     await writeFile(STATE_FILE, text, "utf-8");
-    console.log(`  state set: "${text}"`);
+    console.log(`  self-report set: "${text}"`);
 }
 async function cmdClear() {
     await mkdir(CADENCE_DIR, { recursive: true });
     await writeFile(STATE_FILE, "", "utf-8");
-    console.log("  state cleared");
+    console.log("  self-report cleared");
 }
 // Collects live signals and renders the exact block the hook would inject,
 // or null when there's nothing to say. Shared by `test` and the bare command.
 async function buildPreview() {
     const signals = [];
-    const [music, report, ambient, git, overrides] = await Promise.all([
-        getMusicSignal().catch(() => null),
+    const providers = await loadProviders();
+    const [music, report, environment, git, esoteric, overrides] = await Promise.all([
+        getMusicSignal(providers).catch(() => null),
         getSelfReportSignal().catch(() => null),
-        getAmbientSignal(new Date()).catch(() => null),
+        getEnvironmentSignal(new Date(), {
+            focusedAppEnabled: providerEnabled(providers, "focusedApp"),
+            wifiEnabled: providerEnabled(providers, "wifi"),
+        }).catch(() => null),
         getGitSignal(process.cwd()).catch(() => null),
+        getEsotericSignal(providers).catch(() => null),
         loadOverrides(),
     ]);
     if (music)
         signals.push(music);
     if (report)
         signals.push(report);
-    if (ambient)
-        signals.push(ambient);
+    if (environment)
+        signals.push(environment);
     if (git)
         signals.push(git);
+    if (esoteric)
+        signals.push(esoteric);
     if (signals.length === 0 && Object.keys(overrides).length === 0)
         return null;
     const state = { signals, capturedAt: Date.now() };
@@ -62,7 +84,7 @@ async function buildPreview() {
 async function cmdTest() {
     const block = await buildPreview();
     if (!block) {
-        console.log('  (no signals — play something, set: cadence state "...", or pin a dial: cadence set pace fast)');
+        console.log('  (no signals — play something, set: cadence report "...", or pin a dial: cadence set pace fast)');
         return;
     }
     console.log("\n" + block + "\n");
@@ -70,16 +92,173 @@ async function cmdTest() {
 // The legibility view: every signal Cadence can read — live value, or the
 // reason it's absent. Unlike `test`, this never goes silent.
 async function cmdSignals() {
-    const [music, report, ambient, git] = await Promise.all([
+    const providers = await loadProviders();
+    const [music, report, environment, git] = await Promise.all([
         getMusicSignal().catch(() => null),
         getSelfReportSignal().catch(() => null),
-        getAmbientSignal(new Date()).catch(() => null),
+        getEnvironmentSignal(new Date(), {
+            focusedAppEnabled: providerEnabled(providers, "focusedApp"),
+            wifiEnabled: providerEnabled(providers, "wifi"),
+        }).catch(() => null),
         getGitSignal(process.cwd()).catch(() => null),
     ]);
     console.log("\n" +
-        renderSignalsTable({ music, report, ambient, git, now: Date.now(), platform: process.platform }) +
+        renderSignalsTable({
+            music,
+            report,
+            environment,
+            git,
+            providers,
+            now: Date.now(),
+            platform: process.platform,
+        }) +
         "\n");
 }
+// ── opt-in provider registry: the consent layer ────────────────────────────
+async function loadCfg() {
+    try {
+        return JSON.parse(await readFile(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+async function saveCfg(cfg) {
+    await mkdir(CADENCE_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
+}
+function cfgProviders(cfg) {
+    return cfg["providers"] && typeof cfg["providers"] === "object"
+        ? cfg["providers"]
+        : {};
+}
+function knownProvider(name) {
+    return name != null && name in OPT_IN_PROVIDERS;
+}
+function listProviders() {
+    console.log("  opt-in signals (off until you enable them):");
+    for (const [name, desc] of Object.entries(OPT_IN_PROVIDERS)) {
+        console.log(`    ${name.padEnd(14)} ${desc}`);
+    }
+}
+async function cmdEnable(args) {
+    const [name, ...valueParts] = args;
+    if (!name) {
+        console.log("  usage: cadence enable <signal> [value]   e.g. cadence enable typingTempo");
+        listProviders();
+        return;
+    }
+    if (!knownProvider(name)) {
+        console.error(`  unknown signal "${name}".`);
+        if (name === "spotify")
+            console.error("  spotify takes credentials — run: cadence spotify");
+        listProviders();
+        process.exit(1);
+    }
+    const cfg = await loadCfg();
+    const providers = cfgProviders(cfg);
+    providers[name] = valueParts.length ? valueParts.join(" ") : true;
+    cfg["providers"] = providers;
+    await saveCfg(cfg);
+    console.log(`  enabled ${name}${valueParts.length ? ` = "${valueParts.join(" ")}"` : ""}`);
+}
+// The whole-product kill switch. State (pins, opt-ins, self-report) survives a
+// pause untouched — resume picks up exactly where you left off.
+async function cmdPause() {
+    const cfg = await loadCfg();
+    cfg["paused"] = true;
+    await saveCfg(cfg);
+    console.log("  cadence paused — prompts go through untouched. resume: cadence resume");
+}
+async function cmdResume() {
+    const cfg = await loadCfg();
+    delete cfg["paused"];
+    await saveCfg(cfg);
+    console.log("  cadence resumed — reading the room again. preview: cadence test");
+}
+async function cmdDisable(args) {
+    const [name] = args;
+    if (!name) {
+        console.log("  usage: cadence disable <signal>");
+        listProviders();
+        return;
+    }
+    const cfg = await loadCfg();
+    const providers = cfgProviders(cfg);
+    delete providers[name];
+    cfg["providers"] = providers;
+    await saveCfg(cfg);
+    console.log(`  disabled ${name}`);
+}
+// Spotify is the cross-platform music source — opt-in, browser-authorized via
+// PKCE (no client secret to keep). Bring your own Spotify app client id (or
+// bake one in below / via env for a zero-config experience).
+const DEFAULT_SPOTIFY_CLIENT_ID = ""; // register a "Cadence" app and set this to ship zero-config
+const SPOTIFY_HELP = `  cadence spotify — link Spotify as a cross-platform now-playing source
+
+  macOS already reads Spotify.app / Music.app with zero setup. This is for
+  Linux / Windows (or anyone not scripting the desktop app).
+
+  One-time setup, then we handle the token dance for you:
+    1. Create an app at https://developer.spotify.com/dashboard
+    2. Add this redirect URI to it: ${REDIRECT_URI}
+    3. cadence spotify connect <clientId>   (opens your browser once)
+
+  Then it's just another music signal — vibe still comes from MusicBrainz.
+  Advanced (skip the browser): cadence spotify <clientId> <refreshToken>
+  Turn it off: cadence spotify off`;
+async function cmdSpotifyConnect(clientIdArg) {
+    const clientId = clientIdArg || process.env["CADENCE_SPOTIFY_CLIENT_ID"] || DEFAULT_SPOTIFY_CLIENT_ID;
+    if (!clientId) {
+        console.log("  cadence spotify connect needs a Spotify app client id.\n");
+        console.log(SPOTIFY_HELP);
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        console.log("  spotify connect is interactive — run it in a terminal.");
+        return;
+    }
+    try {
+        const refreshToken = await connectSpotify(clientId, (m) => console.log(m));
+        const cfg = await loadCfg();
+        const providers = cfgProviders(cfg);
+        providers["spotify"] = { clientId, refreshToken };
+        cfg["providers"] = providers;
+        await saveCfg(cfg);
+        console.log("  ✓ Spotify linked — currently-playing is now a cross-platform signal");
+    }
+    catch (e) {
+        console.error(`  couldn't link Spotify: ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+    }
+}
+async function cmdSpotify(args) {
+    const [first, second, third] = args;
+    if (first === "connect")
+        return cmdSpotifyConnect(second);
+    if (first === "off") {
+        const cfg = await loadCfg();
+        const providers = cfgProviders(cfg);
+        delete providers["spotify"];
+        cfg["providers"] = providers;
+        await saveCfg(cfg);
+        console.log("  unlinked Spotify");
+        return;
+    }
+    // advanced manual path: clientId + refreshToken (+ optional secret)
+    if (first && second) {
+        const cfg = await loadCfg();
+        const providers = cfgProviders(cfg);
+        providers["spotify"] = third
+            ? { clientId: first, refreshToken: second, clientSecret: third }
+            : { clientId: first, refreshToken: second };
+        cfg["providers"] = providers;
+        await saveCfg(cfg);
+        console.log("  Spotify linked — currently-playing is now a cross-platform signal");
+        return;
+    }
+    console.log(SPOTIFY_HELP);
+}
 const LEVELS = ["low", "medium", "high"];
 async function cmdSet(args) {
     const [dial, value] = args;
@@ -189,18 +368,23 @@ async function hasUserInput() {
     return state.trim().length > 0 || Object.keys(cfg).length > 0;
 }
 const INPUTS_FOOTER = `  where you can input:
-    cadence state "..."              how you are right now (4h TTL)
+    cadence report "..."              how you are right now (2h TTL)
     cadence set <dial> <level>       pin a dial: ${DIALS.join(", ")}
     cadence set-location <lat> <lon> opt into weather
     cadence start                    interactive setup
     cadence help                     everything else`;
 // Bare \`cadence\`: live status + where to input — not a help dump.
 async function cmdRoot() {
+    if (await isPaused()) {
+        console.log("\n  cadence is paused — prompts go through untouched.");
+        console.log("  resume: cadence resume\n");
+        return;
+    }
     if (!(await hasUserInput())) {
         console.log("\n  cadence — agents that read the room");
         console.log("  It hasn't heard from you yet. Fastest start:\n");
         console.log('    cadence start              guided setup (~30s)');
-        console.log('    cadence state "ship mode"  or just say how you are\n');
+        console.log('    cadence report "ship mode"  or just say how you are\n');
         return;
     }
     const block = await buildPreview();
@@ -215,7 +399,7 @@ async function cmdRoot() {
 // Guided first run: three prompts, every one skippable, nothing destructive.
 async function cmdStart() {
     if (!process.stdin.isTTY) {
-        console.log('  cadence start is interactive — run it in a terminal, or use: cadence state "..."');
+        console.log('  cadence start is interactive — run it in a terminal, or use: cadence report "..."');
         return;
     }
     const { createInterface } = await import("node:readline/promises");
@@ -228,10 +412,10 @@ async function cmdStart() {
         if (state) {
             await mkdir(CADENCE_DIR, { recursive: true });
             await writeFile(STATE_FILE, state, "utf-8");
-            console.log('       ✓ set — expires after 4h; update anytime: cadence state "..."\n');
+            console.log('       ✓ set — expires after 2h; update anytime: cadence report "..."\n');
         }
         else {
-            console.log('       skipped — later: cadence state "..."\n');
+            console.log('       skipped — later: cadence report "..."\n');
         }
         // 2 ── dial pins: overrides, so only offered, never pushed
         console.log(`  2/3  Pin any dials? Pins override inference until unset.`);
@@ -279,12 +463,15 @@ const HELP = `
 
   daily:
     cadence                     live status + where to input
-    cadence start               guided setup (state, dials, weather — all skippable)
-    cadence state "..."         set self-reported state (e.g. "two beers, ship mode")
-    cadence state               print current self-reported state
-    cadence clear               clear self-reported state
+    cadence start               guided setup (self-report, dials, weather — all skippable)
+    cadence report "..."        set your self-report (e.g. "two beers, ship mode")
+    cadence report              print current self-report
+                                ("cadence state" still works as an alias)
+    cadence clear               clear self-report
     cadence test                preview what the hook would inject right now
     cadence signals             every signal — live value, or why it's absent
+    cadence pause               silence all hooks (state survives untouched)
+    cadence resume              start reading the room again
 
   dials (your determination — pinned dials override inference):
     cadence dials               show the mixing board and what's pinned
@@ -293,16 +480,28 @@ const HELP = `
                                 dials: pace, tone, posture, proactivity
                                 (env also works: CADENCE_PACE=fast)
 
-  ambient (time & day are automatic; weather is opt-in):
+  environment (time & day are automatic; weather is opt-in):
     cadence set-location <lat> <lon> [name]   turn on weather for your area
+
+  opt-in signals (off until you turn them on — as much as you're willing to give):
+    cadence enable <signal> [value]   turn an opt-in signal on (e.g. typingTempo)
+    cadence disable <signal>          turn it back off
+                                      see them all: cadence signals
+
+  music (macOS reads Spotify.app / Music.app automatically):
+    cadence spotify connect <id>      link Spotify (cross-platform, opens browser)
+    cadence spotify off               unlink it
 `;
 async function main() {
     const [cmd, ...rest] = process.argv.slice(2);
     switch (cmd) {
         case "start":
             return cmdStart();
-        case "state":
-            return cmdState(rest);
+        case "report":
+            return cmdReport(rest);
+        case "state": // deprecated alias for `report` — kept for alpha installs
+            console.error('  note: "cadence state" is now "cadence report" (alias kept for now)');
+            return cmdReport(rest);
         case "clear":
             return cmdClear();
         case "test":
@@ -317,6 +516,16 @@ async function main() {
             return cmdDials();
         case "set-location":
             return cmdLocation(rest);
+        case "pause":
+            return cmdPause();
+        case "resume":
+            return cmdResume();
+        case "enable":
+            return cmdEnable(rest);
+        case "disable":
+            return cmdDisable(rest);
+        case "spotify":
+            return cmdSpotify(rest);
         case undefined:
             return cmdRoot(); // live status + inputs, not the help dump
         case "help":

package/dist/config.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/* ─────────────────────────────────────────────────────────────────────────
+ * Config + the opt-in provider registry.
+ *
+ * `~/.cadence/config.json` already held pinned dials and a weather location.
+ * It now also holds a `providers` block — the consent registry. Signals that
+ * read something the user might not want shared (their calendar, the app
+ * they're in, an esoteric feed) stay OFF until the user names them here:
+ *
+ *   { "providers": { "typingTempo": true, "focusedApp": true,
+ *                     "calendar": { "ics": "https://…" }, "horoscope": "leo" } }
+ *
+ * The rule is "as many signals as the user is willing to give": nothing
+ * privacy-adjacent fires on inference alone. Always resolves — a missing or
+ * garbled file reads as "nothing opted in," never throws.
+ * ───────────────────────────────────────────────────────────────────────── */
+const CONFIG_FILE = join(homedir(), ".cadence", "config.json");
+/* The opt-in signals the user can turn on, and a one-line description for the
+ * CLI. Adding a row here is what makes `cadence enable <name>` accept it — the
+ * single source of truth shared by the CLI, the signals view, and the
+ * providers. Grow this as opt-in providers land. */
+export const OPT_IN_PROVIDERS = {
+    typingTempo: "prompt rhythm — rapid-fire vs. one long considered prompt → pace",
+    focusedApp: "frontmost non-terminal app (macOS) → flavor in the context line",
+    wifi: "wifi network name (macOS) → place context, home vs. office vs. café",
+    moon: "current moon phase (offline) → esoteric flavor",
+    horoscope: "daily horoscope for your sign, e.g. `cadence enable horoscope leo`",
+};
+export async function loadConfig() {
+    try {
+        const raw = JSON.parse(await readFile(CONFIG_FILE, "utf-8"));
+        return raw && typeof raw === "object" ? raw : {};
+    }
+    catch {
+        return {}; // no/garbled config → empty, never throw
+    }
+}
+/** The opt-in registry, or `{}` if the user hasn't opted into anything. */
+export function readProviders(cfg) {
+    const p = cfg["providers"];
+    return p && typeof p === "object" ? p : {};
+}
+export async function loadProviders() {
+    return readProviders(await loadConfig());
+}
+/* A provider is enabled when its key carries a truthy value: `true`, a config
+ * object (`{ ics: "…" }`), or a setting string (`"leo"`). `false`, `null`,
+ * empty string, or an empty object all read as "off" — tri-state honesty, so
+ * `"horoscope": ""` doesn't silently count as consent. */
+export function providerEnabled(providers, name) {
+    const v = providers[name];
+    if (v == null || v === false || v === "")
+        return false;
+    if (typeof v === "object")
+        return Object.keys(v).length > 0;
+    return Boolean(v);
+}
+/** The raw setting for a provider (e.g. the horoscope sign, the calendar ics
+ * object), or undefined when it's off. Lets a provider read its own config
+ * without re-parsing the file. */
+export function providerSetting(providers, name) {
+    return providerEnabled(providers, name) ? providers[name] : undefined;
+}
+/* ── pause: the whole-product kill switch ──────────────────────────────────
+ * An ambient layer that injects into every prompt needs a visible, instant
+ * off switch. `cadence pause` sets `"paused": true`; every hook checks it
+ * FIRST and exits silently — no signals read, no subprocesses spawned, no
+ * block injected. State (pins, opt-ins, self-report) is preserved untouched,
+ * so `cadence resume` picks up exactly where you left off. */
+export function readPaused(cfg) {
+    return cfg["paused"] === true;
+}
+export async function isPaused() {
+    return readPaused(await loadConfig());
+}

package/dist/hook.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import { getMusicSignal } from "./providers/music.js";
 import { getSelfReportSignal } from "./providers/selfreport.js";
-import { getAmbientSignal } from "./providers/ambient.js";
+import { getEnvironmentSignal } from "./providers/environment.js";
 import { getGitSignal } from "./providers/git.js";
 import { getActivitySignal } from "./providers/activity.js";
+import { getIntentSignal } from "./providers/intent.js";
+import { getEsotericSignal } from "./providers/esoteric.js";
 import { deriveCadence, buildReframe, loadOverrides, applyOverrides } from "./cadence.js";
+import { loadProviders, providerEnabled, isPaused } from "./config.js";
 import { render } from "./inject.js";
 import { debug } from "./debug.js";
 const TOTAL_BUDGET_MS = 1500;
@@ -27,39 +30,56 @@ async function readStdin() {
         return {};
     }
 }
-async function collectSignals(cwd, prompt) {
-    const [music, report, ambient, git, activity] = await Promise.allSettled([
-        getMusicSignal(),
+async function collectSignals(cwd, prompt, providers) {
+    const tempoEnabled = providerEnabled(providers, "typingTempo");
+    const [music, report, environment, git, activity, intent, esoteric] = await Promise.allSettled([
+        getMusicSignal(providers),
         getSelfReportSignal(),
-        getAmbientSignal(new Date()),
+        getEnvironmentSignal(new Date(), {
+            focusedAppEnabled: providerEnabled(providers, "focusedApp"),
+            wifiEnabled: providerEnabled(providers, "wifi"),
+        }),
         getGitSignal(cwd),
-        getActivitySignal(prompt),
+        getActivitySignal(prompt, Date.now(), { tempoEnabled }),
+        getIntentSignal(prompt),
+        getEsotericSignal(providers),
     ]);
     const signals = [];
     if (music.status === "fulfilled" && music.value)
         signals.push(music.value);
     if (report.status === "fulfilled" && report.value)
         signals.push(report.value);
-    if (ambient.status === "fulfilled" && ambient.value)
-        signals.push(ambient.value);
+    if (environment.status === "fulfilled" && environment.value)
+        signals.push(environment.value);
     if (git.status === "fulfilled" && git.value)
         signals.push(git.value);
     if (activity.status === "fulfilled" && activity.value)
         signals.push(activity.value);
+    if (intent.status === "fulfilled" && intent.value)
+        signals.push(intent.value);
+    if (esoteric.status === "fulfilled" && esoteric.value)
+        signals.push(esoteric.value);
     return signals;
 }
 async function main() {
+    // Paused = the user asked for silence. Check FIRST: no signals read, no
+    // subprocesses spawned, nothing injected. `cadence resume` turns it back on.
+    if (await isPaused())
+        process.exit(0);
     const { cwd, prompt } = await readStdin();
     const projectDir = cwd ?? process.cwd();
-    const [signals, overrides] = await Promise.all([
-        Promise.race([
-            collectSignals(projectDir, prompt),
-            new Promise((resolve) => setTimeout(() => {
-                debug("hook", `signal collection exceeded ${TOTAL_BUDGET_MS}ms budget — injecting without signals`);
-                resolve([]);
-            }, TOTAL_BUDGET_MS)),
-        ]),
-        loadOverrides(),
+    // Pins + the opt-in registry are tiny local reads; load them first so signal
+    // collection knows which opt-in providers to run, then race only the
+    // subprocess-heavy collection against the budget.
+    const [overrides, providers] = await Promise.all([loadOverrides(), loadProviders()]);
+    const signals = await Promise.race([
+        collectSignals(projectDir, prompt, providers),
+        // unref: the losing timer must not hold the process open after the
+        // race settles — Claude Code waits on our EXIT, not our output.
+        new Promise((resolve) => setTimeout(() => {
+            debug("hook", `signal collection exceeded ${TOTAL_BUDGET_MS}ms budget — injecting without signals`);
+            resolve([]);
+        }, TOTAL_BUDGET_MS).unref()),
     ]);
     // Nothing to say: no signals AND no pinned dials.
     if (signals.length === 0 && Object.keys(overrides).length === 0) {
@@ -70,12 +90,14 @@ async function main() {
     const reframe = buildReframe(cadence);
     const stateWithCadence = { ...state, cadence, pinned, reframe };
     const block = render(stateWithCadence);
+    // Exit in the write callback (stdout to a pipe can flush async): a straggling
+    // provider subprocess must never keep the user's prompt waiting on our exit.
     process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
             hookEventName: "UserPromptSubmit",
             additionalContext: block,
         },
-    }));
+    }), () => process.exit(0));
 }
 main().catch((err) => {
     const msg = err instanceof Error ? err.message : String(err);

package/dist/inject.js

@@ -28,10 +28,16 @@ function renderGit(g) {
     ].filter(Boolean);
     return `    git: ${parts.join(", ")}`;
 }
+function renderIntent(i) {
+    if (!i.kind)
+        return [];
+    return [`    intent: ${i.kind} (read from your prompt)`];
+}
 function renderActivity(a) {
     const parts = [
         a.minSinceLastPrompt != null ? `min_since_prompt=${a.minSinceLastPrompt}` : null,
         a.promptLength != null ? `prompt_len=${a.promptLength}` : null,
+        a.tempo ? `tempo=${a.tempo}` : null,
     ].filter(Boolean);
     return `    activity: { ${parts.join(" ")} }`;
 }
@@ -42,7 +48,7 @@ function renderPlace(p) {
     ].filter(Boolean);
     return `    place: { ${parts.join(" ")} }`;
 }
-function renderAmbient(a) {
+function renderEnvironment(a) {
     // Human-readable atmosphere line, e.g.
     //   "friday late night, rainy, unplugged 8%, dark mode, on Home-wifi, up 14h"
     const parts = [
@@ -52,6 +58,7 @@ function renderAmbient(a) {
             ? `unplugged${a.batteryPct != null ? ` ${a.batteryPct}%` : ""}`
             : null,
         a.focus === true ? "focus on" : null,
+        a.focusedApp ? `in ${quote(a.focusedApp)}` : null,
         a.darkMode === true ? "dark mode" : null,
         a.displays != null && a.displays > 1 ? `${a.displays} displays` : null,
         a.network ? `on ${quote(a.network)}` : null,
@@ -60,6 +67,13 @@ function renderAmbient(a) {
     ].filter(Boolean);
     return `    context: ${parts.join(", ")}`;
 }
+function renderEsoteric(e) {
+    const parts = [
+        e.moonPhase ? `moon ${e.moonPhase}` : null,
+        e.horoscope ? `${e.sign ?? "horoscope"}: ${quote(e.horoscope)}` : null,
+    ].filter(Boolean);
+    return parts.length ? [`    esoteric: ${parts.join(" · ")}`] : [];
+}
 function renderCadence(c, pinned) {
     const dials = Object.keys(DIAL_WORDS)
         .map((d) => {
@@ -78,12 +92,16 @@ export function render(state) {
             lines.push(renderReport(sig));
         else if (sig.source === "git")
             lines.push(renderGit(sig));
+        else if (sig.source === "intent")
+            lines.push(...renderIntent(sig));
         else if (sig.source === "activity")
             lines.push(renderActivity(sig));
         else if (sig.source === "place")
             lines.push(renderPlace(sig));
-        else if (sig.source === "ambient")
-            lines.push(renderAmbient(sig));
+        else if (sig.source === "environment")
+            lines.push(renderEnvironment(sig));
+        else if (sig.source === "esoteric")
+            lines.push(...renderEsoteric(sig));
     }
     // Render even with zero signals if the user pinned dials — a hand-set board
     // is itself a signal worth injecting.