@cullumco/cadence 0.1.5 → 0.1.6

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cadence",
   "displayName": "Cadence",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Ambient context for Claude Code: embodied signals, cadence dials, and finish-line guardrails. macOS-only alpha.",
   "author": {
     "name": "Cullum&Co",

package/README.md

@@ -67,8 +67,8 @@ deliberate self-report just outranks it.
 **Signals → dials → a reframe lens.**
 
 1. **Signals** — what Cadence can sense right now:
-   - **ambient** — time of day, day of week, weather (opt-in), battery, machine
-     uptime/load, dark mode, displays, wifi, Focus/DND. Mostly zero-setup;
+   - **environment** — time of day, day of week, weather (opt-in), battery, machine
+     uptime/load, dark mode, displays, wifi (opt-in), Focus/DND. Mostly zero-setup;
      time/day work everywhere, the Mac-context probes are macOS. The one signal
      that's always there: `context: friday afternoon, rainy, focus on`.
      (Focus detection reads the DND database directly, so it needs your
@@ -112,7 +112,7 @@ without checking in stays your call, not the soundtrack's.
 ## Requirements
 
 - **Built for the Mac.** The richest ambient probes — music via AppleScript
-  now-playing, battery, dark mode, displays, wifi, Focus/DND, focused app —
+  now-playing, battery, dark mode, displays, wifi (opt-in), Focus/DND, focused app —
   read the Mac around you. On other platforms Cadence still runs and still
   moves the dials: prompt intent, self-report, git, time/day, and typing tempo
   work anywhere, Spotify can be linked for music, and the Mac-only probes
@@ -285,7 +285,7 @@ See [`BACKLOG.md`](BACKLOG.md). Highlights:
 ## Caveats
 
 - **Built for the Mac.** The richest ambient probes (music-via-OS, battery,
-  dark mode, displays, wifi, Focus, focused app) are macOS. Other platforms
+  dark mode, displays, wifi (opt-in), Focus, focused app) are macOS. Other platforms
   keep the dial-movers — intent, self-report, git, time/day, typing tempo,
   linked Spotify — and the rest degrades silently.
 - **Spotify's audio-features API is not used** — Spotify deprecated it for new

package/dist/cli.js

@@ -3,7 +3,7 @@ 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 { 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";
@@ -17,24 +17,36 @@ const STATE_FILE = join(CADENCE_DIR, "state.txt");
 const CONFIG_FILE = join(CADENCE_DIR, "config.json");
 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.
@@ -46,6 +58,7 @@ async function buildPreview() {
         getSelfReportSignal().catch(() => null),
         getEnvironmentSignal(new Date(), {
             focusedAppEnabled: providerEnabled(providers, "focusedApp"),
+            wifiEnabled: providerEnabled(providers, "wifi"),
         }).catch(() => null),
         getGitSignal(process.cwd()).catch(() => null),
         getEsotericSignal(providers).catch(() => null),
@@ -79,12 +92,15 @@ 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, environment, git, providers] = await Promise.all([
+    const providers = await loadProviders();
+    const [music, report, environment, git] = await Promise.all([
         getMusicSignal().catch(() => null),
         getSelfReportSignal().catch(() => null),
-        getEnvironmentSignal(new Date()).catch(() => null),
+        getEnvironmentSignal(new Date(), {
+            focusedAppEnabled: providerEnabled(providers, "focusedApp"),
+            wifiEnabled: providerEnabled(providers, "wifi"),
+        }).catch(() => null),
         getGitSignal(process.cwd()).catch(() => null),
-        loadProviders(),
     ]);
     console.log("\n" +
         renderSignalsTable({

package/dist/config.js

@@ -24,6 +24,7 @@ const CONFIG_FILE = join(homedir(), ".cadence", "config.json");
 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`",
 };

package/dist/hook.js

@@ -35,7 +35,10 @@ async function collectSignals(cwd, prompt, providers) {
     const [music, report, environment, git, activity, intent, esoteric] = await Promise.allSettled([
         getMusicSignal(providers),
         getSelfReportSignal(),
-        getEnvironmentSignal(new Date(), { focusedAppEnabled: providerEnabled(providers, "focusedApp") }),
+        getEnvironmentSignal(new Date(), {
+            focusedAppEnabled: providerEnabled(providers, "focusedApp"),
+            wifiEnabled: providerEnabled(providers, "wifi"),
+        }),
         getGitSignal(cwd),
         getActivitySignal(prompt, Date.now(), { tempoEnabled }),
         getIntentSignal(prompt),

package/dist/posttool.js

@@ -14,15 +14,17 @@ import { isPaused } from "./config.js";
  * event: the repo entering or leaving a merge/rebase conflict — the
  * strongest debug tell we have, far stronger than music ever was.
  *
- * Two material events now, same discipline:
+ * Three material events now, same discipline:
  *   1. the repo entering/leaving a merge/rebase conflict (re-observed via git)
  *   2. a streak of destructive git ops — reset --hard / force-push — read off
  *      the command string (no tool_response parsing), i.e. thrash.
+ *   3. the test suite entering/leaving a failing state — read off the output
+ *      of test-runner commands, tri-state honest (can't tell → don't update).
  *
  * Discipline (the BACKLOG's hard constraint):
- *   - fires only after Bash tool calls whose command mentions git
- *   - injects at most once per TRANSITION (conflict edge, or thrash threshold),
- *     never per tool
+ *   - fires only after Bash tool calls whose command mentions git or a test run
+ *   - injects at most once per TRANSITION (conflict edge, thrash threshold,
+ *     or tests-failing edge), never per tool
  *   - silent in every other case, silent on every error
  * ───────────────────────────────────────────────────────────────────────── */
 const TOTAL_BUDGET_MS = 1500;
@@ -30,14 +32,26 @@ const STATE_FILE = join(homedir(), ".cadence", "workstate.json");
 const MAX_SESSIONS = 20;
 const THRASH_WINDOW_MS = 10 * 60_000; // destructive ops within 10 min count as a streak
 const THRASH_MIN = 2; // 2nd destructive op in the window = thrash
-// Gate 1: is this tool call even capable of changing git conflict state?
-// Only Bash commands that mention git — Edit/Read/etc. can't start a merge,
-// and checking the repo after every tool call would betray the silence rule.
+// Does this command run a test suite? Phrase-based like intent.ts — runner
+// names and `npm test`-shaped invocations, not the bare word "test" (which
+// would match `git stash list | grep test`). Pure + exported for tests.
+export function isTestCommand(cmd) {
+    return (/\b(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?test\b/.test(cmd) ||
+        /\bnode\s+--test\b/.test(cmd) ||
+        /\b(?:jest|vitest|mocha|pytest|tape|ava)\b/.test(cmd) ||
+        /\bgo\s+test\b/.test(cmd) ||
+        /\bcargo\s+test\b/.test(cmd));
+}
+// Gate 1: is this tool call even capable of changing what we observe?
+// Only Bash commands that mention git (conflict/thrash) or run tests —
+// checking after every tool call would betray the silence rule.
 export function shouldCheck(input) {
     if (input.tool_name !== "Bash")
         return false;
     const cmd = input.tool_input?.command;
-    return typeof cmd === "string" && /\bgit\b/.test(cmd);
+    if (typeof cmd !== "string")
+        return false;
+    return /\bgit\b/.test(cmd) || isTestCommand(cmd);
 }
 // Gate 2: did the observed state actually TRANSITION? Speak only on the edge.
 //   undefined → true   first observation reveals a conflict → speak
@@ -59,6 +73,50 @@ export function refineContext(prev, conflicted) {
     }
     return null; // first observation of a clean repo: record silently
 }
+/* Did the test run fail? Tri-state honest, read off the runner's own summary:
+ *   true       a nonzero failure count, or an unambiguous failure marker
+ *   false      an explicit zero-failure count, or passes with no failure marks
+ *   undefined  can't tell → caller must NOT update state (couldn't look ≠ ok)
+ * Counts beat markers: "✖ 0 failing" is a pass even though ✖ appears. */
+export function testsFailedFrom(resp) {
+    if (resp == null)
+        return undefined;
+    const text = typeof resp === "string" ? resp : JSON.stringify(resp);
+    if (!text)
+        return undefined;
+    // explicit counts, either word order: "2 failed" / "fail 2" / "failures: 0"
+    const counts = [
+        ...text.matchAll(/(\d+)\s*(?:tests?\s+)?fail(?:ed|ing|ures?)?\b/gi),
+        ...text.matchAll(/\bfail(?:ed|ing|ures?)?[:\s]+(\d+)/gi),
+    ].map((m) => Number(m[1]));
+    if (counts.some((n) => n > 0))
+        return true;
+    if (counts.length > 0)
+        return false;
+    // unambiguous markers (go test FAIL, TAP "not ok", node/jest ✖ lists)
+    if (/\bFAIL(?:ED)?\b/.test(text) || /\bnot ok\b/.test(text) || /✖/.test(text))
+        return true;
+    // passes with no failure marks anywhere
+    if (/\b\d+\s+pass(?:ed|ing)?\b/i.test(text) || /\bok\b/.test(text))
+        return false;
+    return undefined;
+}
+// Same edge contract as refineContext, for the tests-failing state.
+export function refineTests(prev, failing) {
+    if (prev === failing)
+        return null;
+    if (failing) {
+        return ("<user_state_update>observed work: the test suite just started failing. " +
+            "Read the cadence as debug now — verify before building further, and " +
+            "treat the failures as the current ground truth. If the user's words " +
+            "clearly mean otherwise, follow their words.</user_state_update>");
+    }
+    if (prev === true) {
+        return ("<user_state_update>observed work: the tests are passing again — drop " +
+            "the debug framing and return to the user's prior cadence.</user_state_update>");
+    }
+    return null; // first observation of a passing suite: record silently
+}
 // Is this command a destructive/undo git op? Just `reset --hard` and a true
 // force-push — NOT --force-with-lease (the safe one), checkout, or restore
 // (too ordinary to read as thrash). Pure + exported for tests.
@@ -138,10 +196,15 @@ async function main() {
     const state = await loadState();
     const prev = state[key];
     const now = Date.now();
+    const cmd = typeof input.tool_input?.command === "string" ? input.tool_input.command : "";
     // 1. conflict edge (re-observed via git)
     const conflictMsg = refineContext(prev?.conflicted, git.conflicted);
-    // 2. thrash threshold (read off the command string)
-    const cmd = typeof input.tool_input?.command === "string" ? input.tool_input.command : "";
+    // 2. tests-failing edge (read off the runner's output; tri-state honest —
+    //    an unreadable run keeps the previous observation, it never clears it)
+    const failed = isTestCommand(cmd) ? testsFailedFrom(input.tool_response) : undefined;
+    const testsFailing = failed ?? prev?.testsFailing;
+    const testsMsg = failed != null ? refineTests(prev?.testsFailing, failed) : null;
+    // 3. thrash threshold (read off the command string)
     const times = prev?.thrashTimes ?? [];
     const nextTimes = isThrashCommand(cmd) ? [...times, now] : times;
     const thrash = refineThrash(nextTimes, now, prev?.thrashAnnounced ?? false);
@@ -150,10 +213,11 @@ async function main() {
         at: now,
         thrashTimes: thrash.times,
         thrashAnnounced: thrash.announced,
+        ...(testsFailing != null ? { testsFailing } : {}),
     };
     await saveState(state);
-    // A conflict edge is the stronger tell; fall back to thrash. At most one.
-    const message = conflictMsg ?? thrash.message;
+    // Strongest tell wins: conflict > tests > thrash. At most one message.
+    const message = conflictMsg ?? testsMsg ?? thrash.message;
     if (message) {
         process.stdout.write(JSON.stringify({
             hookSpecificOutput: {

package/dist/providers/environment.js

@@ -1,5 +1,5 @@
 import { exec } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { homedir, uptime, loadavg, cpus } from "node:os";
 import { join } from "node:path";
 // One-liner shell helper for the best-effort macOS probes. Always resolves
@@ -155,12 +155,16 @@ export async function getFocusedApp(now) {
     return name;
 }
 // ── mac context: best-effort shell-outs, all flavor (no dial nudges) ─────────
-async function getMacContext(focusedAppEnabled) {
+async function getMacContext(focusedAppEnabled, wifiEnabled) {
     if (process.platform !== "darwin")
         return {};
     const [dark, ssid, displays, focus, focusedApp] = await Promise.all([
         sh("defaults read -g AppleInterfaceStyle"), // "Dark", or error (=light)
-        sh("ipconfig getsummary en0 | awk -F ' SSID : ' '/ SSID : / {print $2}'", 700),
+        // SSID names your location — opt-in (2026-06-11), like everything
+        // privacy-adjacent. Off → don't even spawn the probe.
+        wifiEnabled
+            ? sh("ipconfig getsummary en0 | awk -F ' SSID : ' '/ SSID : / {print $2}'", 700)
+            : Promise.resolve(null),
         // fast display count via AppleScript (~100ms) — NOT system_profiler (1-3s)
         sh(`osascript -e 'tell application "System Events" to count of desktops'`, 700),
         getFocus(),
@@ -198,6 +202,21 @@ function weatherWord(code) {
         return "snowy";
     return "stormy";
 }
+const WEATHER_CACHE_FILE = join(homedir(), ".cadence", "weather-cache.json");
+// Weather barely moves in half an hour, and the hook + stop hook both ask —
+// without a cache that's two Open-Meteo round-trips per turn for one word.
+const WEATHER_CACHE_MS = 30 * 60_000;
+// Pure freshness check, exported for tests: same location, younger than TTL.
+export function weatherCacheFresh(c, lat, lon, now) {
+    if (!c || typeof c !== "object")
+        return false;
+    const w = c;
+    return (typeof w.word === "string" &&
+        typeof w.at === "number" &&
+        w.lat === lat &&
+        w.lon === lon &&
+        now - w.at <= WEATHER_CACHE_MS);
+}
 async function getWeather() {
     let cfg;
     try {
@@ -209,6 +228,14 @@ async function getWeather() {
     const loc = cfg.location;
     if (!loc || typeof loc.lat !== "number" || typeof loc.lon !== "number")
         return undefined;
+    try {
+        const cached = JSON.parse(await readFile(WEATHER_CACHE_FILE, "utf-8"));
+        if (weatherCacheFresh(cached, loc.lat, loc.lon, Date.now()))
+            return cached.word;
+    }
+    catch {
+        // no cache yet → fetch below
+    }
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(), WEATHER_TIMEOUT_MS);
     try {
@@ -219,7 +246,19 @@ async function getWeather() {
             return undefined;
         const data = (await res.json());
         const code = data.current?.weather_code;
-        return typeof code === "number" ? weatherWord(code) : undefined;
+        if (typeof code !== "number")
+            return undefined;
+        const word = weatherWord(code);
+        try {
+            // best-effort cache write; a miss just means we fetch again next prompt
+            await mkdir(join(homedir(), ".cadence"), { recursive: true });
+            const cache = { word, at: Date.now(), lat: loc.lat, lon: loc.lon };
+            await writeFile(WEATHER_CACHE_FILE, JSON.stringify(cache), "utf-8");
+        }
+        catch {
+            // ignore
+        }
+        return word;
     }
     catch {
         return undefined;
@@ -235,7 +274,7 @@ export async function getEnvironmentSignal(now, opts = {}) {
     const [weather, battery, mac] = await Promise.all([
         getWeather(),
         getBattery(),
-        getMacContext(opts.focusedAppEnabled ?? false),
+        getMacContext(opts.focusedAppEnabled ?? false, opts.wifiEnabled ?? false),
     ]);
     return {
         source: "environment",

package/dist/signals-view.js

@@ -15,7 +15,7 @@ function ttlLeft(setAt, now) {
     const m = Math.floor((rem % 3_600_000) / 60_000);
     return h > 0 ? `${h}h${String(m).padStart(2, "0")}m left` : `${m}m left`;
 }
-function environmentRows(a, platform) {
+function environmentRows(a, platform, providers) {
     if (!a)
         return [top("environment", "— unavailable")];
     const mac = platform === "darwin";
@@ -46,9 +46,11 @@ function environmentRows(a, platform) {
                 : row("displays", String(a.displays), "(hidden: only shows >1)"));
     lines.push(!mac
         ? row("wifi", macNote)
-        : a.network
-            ? row("wifi", JSON.stringify(a.network))
-            : row("wifi", "— unavailable"));
+        : !providerEnabled(providers, "wifi")
+            ? row("wifi", "— off (run: cadence enable wifi)")
+            : a.network
+                ? row("wifi", JSON.stringify(a.network))
+                : row("wifi", "— unavailable (macOS may require Location Services)"));
     lines.push(a.uptimeHours == null
         ? row("uptime", "— unavailable")
         : a.uptimeHours >= 12
@@ -123,7 +125,7 @@ function optInFlavorRows(providers, environment) {
 export function renderSignalsTable(raw) {
     const providers = raw.providers ?? {};
     return [
-        ...environmentRows(raw.environment, raw.platform),
+        ...environmentRows(raw.environment, raw.platform, raw.providers ?? {}),
         ...musicRows(raw.music, providers),
         reportRow(raw.report, raw.now),
         intentRow(),

package/dist/vibe.js

@@ -113,7 +113,7 @@ const GENRE_AFFECT = {
     opera: { energy: 0.5, valence: 0.45, acoustic: 0.9, moods: ["epic"] },
     choral: { energy: 0.3, valence: 0.5, acoustic: 0.95, moods: ["ethereal", "epic"] },
     // ── low energy, low valence → pace low; dark moods are render-only ───
-    //    (valence currently moves NO dial — see BACKLOG "energyToMode boundary")
+    //    (valence currently moves NO dial — see BACKLOG "Valence boundary")
     blues: { energy: 0.45, valence: 0.35, acoustic: 0.5, moods: ["sad", "dark"] },
     goth: { energy: 0.55, valence: 0.3, acoustic: 0.2, moods: ["dark"] },
     gothic: { energy: 0.55, valence: 0.3, acoustic: 0.2, moods: ["dark"] },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cullumco/cadence",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Agents that read the room. Ambient context, cadence dials, and finish-line guardrails for Claude Code. macOS-only alpha.",
   "type": "module",
   "bin": {