@cullumco/cadence 0.1.1 → 0.1.3

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "cadence",
       "displayName": "Cadence",
-      "description": "Agents that read the room: embodied state, cadence dials, and conservative finish-line guardrails for Claude Code.",
+      "description": "Agents that read the room: embodied state, cadence dials, and conservative finish-line guardrails for Claude Code. macOS-only alpha.",
       "source": {
         "source": "npm",
         "package": "@cullumco/cadence"
@@ -21,7 +21,7 @@
         "agents",
         "claude-code"
       ],
-      "homepage": "https://github.com/cullumco/cadence",
+      "homepage": "https://cullumco.github.io/cadence/",
       "repository": "https://github.com/cullumco/cadence",
       "license": "MIT"
     }

package/.claude-plugin/plugin.json

@@ -1,13 +1,13 @@
 {
   "name": "cadence",
   "displayName": "Cadence",
-  "version": "0.1.1",
-  "description": "Ambient context for Claude Code: embodied signals, cadence dials, and finish-line guardrails.",
+  "version": "0.1.3",
+  "description": "Ambient context for Claude Code: embodied signals, cadence dials, and finish-line guardrails. macOS-only alpha.",
   "author": {
     "name": "Cullum&Co",
     "url": "https://cullum.co"
   },
-  "homepage": "https://github.com/cullumco/cadence",
+  "homepage": "https://cullumco.github.io/cadence/",
   "repository": "https://github.com/cullumco/cadence",
   "license": "MIT",
   "keywords": [

package/README.md

@@ -9,7 +9,10 @@ listening to, what you told it, how you want it to respond — into every prompt
 then asks Claude to *read your prompt through that lens*. The agent stops being
 deaf to the room.
 
-A [Cullum&Co](https://cullum.co) project.
+**macOS-only (alpha).** Most signals read the Mac around you; other platforms
+degrade to self-report + dials + time/git.
+
+A [Cullum&Co](https://cullum.co) project · [cullumco.github.io/cadence](https://cullumco.github.io/cadence/)
 
 ## What it does
 
@@ -34,14 +37,38 @@ It doesn't constrain the agent or rewrite your prompt — it gives the model the
 context your words are missing, and a lens for reading them. The lens always
 defers to what you actually typed.
 
+## Same prompt, different room
+
+> "how should I structure the retry logic?"
+
+**Without Cadence** — every prompt reads the same. You get the survey: four
+options, a trade-off table, and a closing "Would you like me to implement one
+of these?"
+
+**With Cadence, shipping cadence** — hardcore at 3 commits/hr, state set to
+`"ship mode"` → `{ pace=fast posture=decisive proactivity=act-freely }`. You
+get the call, made: exponential backoff with jitter, three attempts, here's
+the diff, tests pass.
+
+**With Cadence, thinking cadence** — ambient music, state set to
+`"thinking through tradeoffs"` → `{ pace=deliberate posture=exploratory }`.
+You get the options laid out patiently, trade-offs actually explored, no
+pressure to pick one yet.
+
+Same words. The room around them changed, and the agent finally saw it.
+
 ## How it works
 
 **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. Mostly zero-setup, cross-platform.
-     The one signal that's always there: `context: friday afternoon, rainy`.
+     uptime/load, dark mode, displays, wifi, 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
+     terminal to have Full Disk Access — `cadence signals` tells you if it
+     doesn't.)
    - **git** — commits this hour, dirty files, mid-merge/rebase, read from the
      project you're in: `git: 6 dirty, mid-conflict`. Cross-platform.
    - **activity** — prompt length and minutes since your last prompt, read from
@@ -51,8 +78,10 @@ defers to what you actually typed.
      Spotify login, no API key, no Premium.
    - **self-report** — what you tell it: `cadence state "two beers, shipping"`.
 
-   Time/day and self-report move the dials; the rest render as context the agent
-   reads (flavor). Git's nudges are built but dormant — see `BACKLOG.md`.
+   Time/day, self-report, and git move the dials (git reads *what you're
+   doing*: 3+ commits/hr → fast pace, mid-conflict → verify-first); the rest
+   render as context the agent reads (flavor). Self-report always outranks
+   inference — "I'm shipping" beats a mid-conflict read.
 2. **Dials** — four independent knobs, each `low | medium | high`, inferred from
    the signals (or pinned by you):
    - **pace** — deliberate ↔ fast
@@ -69,9 +98,11 @@ express.
 
 ## Requirements
 
-- **macOS** (the now-playing reader uses AppleScript against Spotify.app /
-  Music.app). The self-report and dials work everywhere; only the music signal
-  is macOS-only.
+- **macOS.** Cadence is mac-only for the alpha: music (AppleScript
+  now-playing), battery, dark mode, displays, wifi, and Focus/DND all read the
+  Mac around you. On other platforms it still runs — self-report, dials,
+  time/day, and git work anywhere, the rest degrade silently — but the product
+  is built for the Mac.
 - **Node 20+**
 - Claude Code for the alpha adapter
 
@@ -114,8 +145,14 @@ cadence state "two beers, shipping"   # set self-reported state (expires in 4h)
 cadence state                         # print current self-report
 cadence clear                         # clear it
 cadence test                          # preview exactly what the hook would inject
+cadence signals                       # every signal — live value, or why it's absent
 ```
 
+`cadence signals` is the legibility view: it never goes silent. Every signal
+Cadence knows how to read is listed with its live value, or the exact reason
+it's absent — opt-in not taken, below a render threshold, missing permission
+(Focus needs Full Disk Access), or platform-gated.
+
 From inside Claude Code, the plugin skill gives the same self-report path:
 
 ```text
@@ -184,17 +221,28 @@ the gate to run on every push to `main`.
 
 See [`BACKLOG.md`](BACKLOG.md). Highlights:
 
-- **More signals** — stronger `git` nudges, calendar density, wifi/place.
-  Git is the highest-value one: it moves the dials from *what you said* to *what
-  you're actually doing*.
-- **After-the-fact injection** — refine the cadence mid-task (`PostToolUse`),
-  building on the conservative finish-line `Stop` guard that now ships.
+- **Git nudges** — the highest-value next step: built but dormant, they move
+  the dials from *what you said* to *what you're actually doing*.
+- **More signals** — candidates on the bench:
+  - **calendar density** — a meeting in 20 minutes should read as `pace=fast,
+    posture=decisive`; a clear afternoon as room to explore.
+  - **typing tempo** — prompt rhythm beyond length: rapid-fire short prompts vs.
+    one long considered one.
+  - **focused app** — what's frontmost next to the terminal (docs? a profiler?
+    Slack?).
+  - **deeper Focus** — manual + scheduled Focus detection ship now; geofenced/
+    iPhone-synced Focus leaves no local trace and stays undetectable.
+- **After-the-fact injection** — the first cut ships: a `PostToolUse` hook
+  watches git-ish commands and speaks exactly once when the repo enters or
+  leaves a merge/rebase conflict ("this is debug now" / "conflict resolved").
+  Next material events: failing-test transitions, reset/force-push thrash.
 - **Opt-in flavor providers** — horoscope, moon phase, for those who want them.
 
 ## Caveats
 
-- **macOS-only music.** The now-playing reader is AppleScript. Other platforms
-  get self-report + dials, just no music vibe.
+- **macOS-only.** The alpha targets the Mac: music, battery, dark mode,
+  displays, wifi, and Focus are all macOS probes. Other platforms get
+  self-report + dials + time/git; everything else degrades silently.
 - **Spotify's Web API is not used** and not needed — Spotify deprecated audio
   features for new apps (2024) and gated dev-mode behind Premium (2026). Cadence
   reads what's playing at the OS level instead.

package/dist/cadence.js

@@ -71,6 +71,16 @@ export function deriveCadence(state) {
     if (music?.vibe && /\b(calm|chilled|ethereal|romantic|warm)\b/.test(music.vibe)) {
         c.tone = "low";
     }
+    // ── git → pace / proactivity (what you're DOING, not what you said) ───────
+    // Enabled 2026-06-05 after the flavor proved trustworthy in real use.
+    // Applied below self-report on purpose: "I'm shipping" beats a mid-conflict
+    // read — the user's explicit word stays the higher authority.
+    if (git) {
+        if (git.commitsLastHour >= 3)
+            c.pace = "high"; // flow state
+        if (git.conflicted)
+            c.proactivity = "low"; // verify, don't barrel
+    }
     // ── self-report → posture / proactivity / tone (you know your state) ──────
     if (report) {
         const t = report.text.toLowerCase();
@@ -92,12 +102,8 @@ export function deriveCadence(state) {
         if (/\b(focused|formal|work|serious|crunch)\b/.test(t))
             c.tone = "high";
     }
-    // ── git: FLAVOR ONLY for now (renders as context, no dial nudges yet) ─────
-    // Candidate nudges, deliberately dormant until we've watched real output:
-    //   conflicted → proactivity low (verify, don't barrel)
-    //   commitsLastHour >= 3 → pace high (flow state)
-    // See BACKLOG: turn these on once the flavor proves trustworthy.
-    void git;
+    // Still-dormant candidate nudges (see BACKLOG):
+    //   ambient focus on → proactivity high (heads-down = fewer check-ins)
     // ── activity → pace (returning from a break = slow back down) ─────────────
     if (activity?.minSinceLastPrompt != null && activity.minSinceLastPrompt > 30) {
         c.pace = "low";

package/dist/cli.js

@@ -8,6 +8,7 @@ import { getAmbientSignal } from "./providers/ambient.js";
 import { getGitSignal } from "./providers/git.js";
 import { deriveCadence, buildReframe, loadOverrides, applyOverrides, resolveDialLevel, DIALS, DIAL_WORDS, } from "./cadence.js";
 import { render } from "./inject.js";
+import { renderSignalsTable } from "./signals-view.js";
 const CADENCE_DIR = join(homedir(), ".cadence");
 const STATE_FILE = join(CADENCE_DIR, "state.txt");
 const CONFIG_FILE = join(CADENCE_DIR, "config.json");
@@ -66,6 +67,19 @@ async function cmdTest() {
     }
     console.log("\n" + block + "\n");
 }
+// 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([
+        getMusicSignal().catch(() => null),
+        getSelfReportSignal().catch(() => null),
+        getAmbientSignal(new Date()).catch(() => null),
+        getGitSignal(process.cwd()).catch(() => null),
+    ]);
+    console.log("\n" +
+        renderSignalsTable({ music, report, ambient, git, now: Date.now(), platform: process.platform }) +
+        "\n");
+}
 const LEVELS = ["low", "medium", "high"];
 async function cmdSet(args) {
     const [dial, value] = args;
@@ -270,6 +284,7 @@ const HELP = `
     cadence state               print current self-reported state
     cadence clear               clear self-reported state
     cadence test                preview what the hook would inject right now
+    cadence signals             every signal — live value, or why it's absent
 
   dials (your determination — pinned dials override inference):
     cadence dials               show the mixing board and what's pinned
@@ -292,6 +307,8 @@ async function main() {
             return cmdClear();
         case "test":
             return cmdTest();
+        case "signals":
+            return cmdSignals();
         case "set":
             return cmdSet(rest);
         case "unset":

package/dist/inject.js

@@ -51,6 +51,7 @@ function renderAmbient(a) {
         a.onBattery === true
             ? `unplugged${a.batteryPct != null ? ` ${a.batteryPct}%` : ""}`
             : null,
+        a.focus === true ? "focus on" : null,
         a.darkMode === true ? "dark mode" : null,
         a.displays != null && a.displays > 1 ? `${a.displays} displays` : null,
         a.network ? `on ${quote(a.network)}` : null,

package/dist/posttool.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { pathToFileURL } from "node:url";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getGitSignal } from "./providers/git.js";
+/* ─────────────────────────────────────────────────────────────────────────
+ * PostToolUse adapter — V2 "after-the-fact" refinement, conservative cut.
+ *
+ * The UserPromptSubmit lens is predictive: it reads AMBIENT state before any
+ * work happens. This hook watches the work itself and speaks only when the
+ * observed work MATERIALLY changes the cadence read. V2's single material
+ * event: the repo entering or leaving a merge/rebase conflict — the
+ * strongest debug tell we have, far stronger than music ever was.
+ *
+ * Discipline (the BACKLOG's hard constraint):
+ *   - fires only after Bash tool calls whose command mentions git
+ *   - injects at most once per conflict-state TRANSITION, never per tool
+ *   - silent in every other case, silent on every error
+ * ───────────────────────────────────────────────────────────────────────── */
+const TOTAL_BUDGET_MS = 1500;
+const STATE_FILE = join(homedir(), ".cadence", "workstate.json");
+const MAX_SESSIONS = 20;
+// 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.
+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);
+}
+// Gate 2: did the observed state actually TRANSITION? Speak only on the edge.
+//   undefined → true   first observation reveals a conflict → speak
+//   false     → true   work just entered a conflict          → speak
+//   true      → false  conflict resolved                     → speak (release)
+//   anything else      no change                             → silent
+export function refineContext(prev, conflicted) {
+    if (prev === conflicted)
+        return null;
+    if (conflicted) {
+        return ("<user_state_update>observed work: the repo just entered a merge/rebase " +
+            "conflict. Read the cadence as debug now — verify the repo state, lead " +
+            "with hypotheses, and don't barrel toward shipping until it's resolved. " +
+            "If the user's words clearly mean otherwise, follow their words.</user_state_update>");
+    }
+    if (prev === true) {
+        return ("<user_state_update>observed work: the conflict is resolved — drop the " +
+            "debug framing and return to the user's prior cadence.</user_state_update>");
+    }
+    return null; // first observation of a clean repo: record silently
+}
+async function loadState() {
+    try {
+        const raw = JSON.parse(await readFile(STATE_FILE, "utf-8"));
+        return raw && typeof raw === "object" ? raw : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function saveState(state) {
+    try {
+        // prune to the newest MAX_SESSIONS so the file can't grow unbounded
+        const entries = Object.entries(state)
+            .sort((a, b) => b[1].at - a[1].at)
+            .slice(0, MAX_SESSIONS);
+        await mkdir(join(homedir(), ".cadence"), { recursive: true });
+        await writeFile(STATE_FILE, JSON.stringify(Object.fromEntries(entries)), "utf-8");
+    }
+    catch {
+        // best-effort; a failed save just means we might speak twice
+    }
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return {};
+    let raw = "";
+    for await (const chunk of process.stdin)
+        raw += chunk;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function main() {
+    const input = await readStdin();
+    if (!shouldCheck(input))
+        return;
+    const git = await Promise.race([
+        getGitSignal(input.cwd ?? process.cwd()).catch(() => null),
+        new Promise((resolve) => setTimeout(() => resolve(null), TOTAL_BUDGET_MS)),
+    ]);
+    if (!git)
+        return; // not a repo / git unavailable → nothing to observe
+    const key = input.session_id ?? "default";
+    const state = await loadState();
+    const prev = state[key]?.conflicted;
+    const message = refineContext(prev, git.conflicted);
+    state[key] = { conflicted: git.conflicted, at: Date.now() };
+    await saveState(state);
+    if (message) {
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: "PostToolUse",
+                additionalContext: message,
+            },
+        }));
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`cadence posttool: ${msg}\n`);
+        process.exit(0); // never block the tool loop
+    });
+}

package/dist/providers/ambient.js

@@ -22,6 +22,9 @@ function sh(cmd, ms = 500) {
  * "Put the vibes back into engineering": this is the atmosphere layer.
  * ───────────────────────────────────────────────────────────────────────── */
 const CONFIG_FILE = join(homedir(), ".cadence", "config.json");
+const DND_DIR = join(homedir(), "Library", "DoNotDisturb", "DB");
+const DND_ASSERTIONS = join(DND_DIR, "Assertions.json");
+const DND_MODE_CONFIGS = join(DND_DIR, "ModeConfigurations.json");
 const WEATHER_TIMEOUT_MS = 900;
 const DAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 function partOfDay(hour) {
@@ -62,19 +65,95 @@ function getVitals() {
     const load1 = loadavg()[0] ?? 0;
     return { uptimeHours, loadHigh: load1 / cores > 0.8 };
 }
+// Is any SCHEDULED Focus window active right now? Pure function over the
+// parsed ModeConfigurations.json (exported for fixture tests). The shape is
+// Apple-private but stable Monterey→Tahoe: each mode's triggers carry
+// enabledSetting (2 = on) and a start/end time-of-day window that may wrap
+// midnight (22:00 → 07:00). Anything unexpected reads as "not active".
+export function scheduleActive(json, now) {
+    try {
+        const configs = json?.data?.[0]?.modeConfigurations;
+        if (!configs || typeof configs !== "object")
+            return false;
+        const minutes = now.getHours() * 60 + now.getMinutes();
+        for (const mode of Object.values(configs)) {
+            const triggers = mode?.triggers?.triggers;
+            if (!Array.isArray(triggers))
+                continue;
+            for (const t of triggers) {
+                const trig = t;
+                if (trig?.enabledSetting !== 2)
+                    continue; // 2 = schedule enabled
+                const { timePeriodStartTimeHour: sh, timePeriodEndTimeHour: eh } = trig;
+                if (typeof sh !== "number" || typeof eh !== "number")
+                    continue;
+                const start = sh * 60 + (trig.timePeriodStartTimeMinute ?? 0);
+                const end = eh * 60 + (trig.timePeriodEndTimeMinute ?? 0);
+                const active = start < end
+                    ? minutes >= start && minutes < end
+                    : minutes >= start || minutes < end; // window wraps midnight
+                if (active)
+                    return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+// Focus / DND — tri-state, read straight from the private donotdisturbd DB
+// (~1ms, no subprocess). Exported for the darwin smoke test.
+//   true      → a Focus mode is asserted (manual toggle) OR a scheduled
+//               Focus window is active right now
+//   false     → assertions read OK, none set, no schedule active → off
+//   undefined → unreadable: terminal lacks Full Disk Access (TCC denies the
+//               read silently — hook subprocesses never get a prompt), file
+//               moved, or shape changed → "unavailable", never "off"
+// Remaining gap: geofenced/iPhone-synced Focus writes neither an assertion
+// nor a local schedule — undetectable from this Mac.
+export async function getFocus(now = new Date()) {
+    if (process.platform !== "darwin")
+        return undefined;
+    let manual;
+    try {
+        const raw = await readFile(DND_ASSERTIONS, "utf-8");
+        const json = JSON.parse(raw);
+        const records = json.data?.[0]?.storeAssertionRecords;
+        manual = Array.isArray(records) && records.length > 0;
+    }
+    catch {
+        manual = undefined;
+    }
+    if (manual)
+        return true;
+    // Manual focus is off (or unknowable) — a scheduled window may still be on.
+    try {
+        const raw = await readFile(DND_MODE_CONFIGS, "utf-8");
+        if (scheduleActive(JSON.parse(raw), now))
+            return true;
+    }
+    catch {
+        // both files unreadable → truly unknown
+    }
+    return manual;
+}
 // ── mac context: best-effort shell-outs, all flavor (no dial nudges) ─────────
 async function getMacContext() {
     if (process.platform !== "darwin")
         return {};
-    const [dark, ssid, displays] = await Promise.all([
+    const [dark, ssid, displays, focus] = await Promise.all([
         sh("defaults read -g AppleInterfaceStyle"), // "Dark", or error (=light)
         sh("ipconfig getsummary en0 | awk -F ' SSID : ' '/ SSID : / {print $2}'", 700),
         // fast display count via AppleScript (~100ms) — NOT system_profiler (1-3s)
         sh(`osascript -e 'tell application "System Events" to count of desktops'`, 700),
+        getFocus(),
     ]);
     const ctx = {};
-    if (dark != null)
-        ctx.darkMode = /dark/i.test(dark);
+    // `defaults read` exits non-zero when the key is unset — which is exactly
+    // what light mode looks like. So error/null ⇒ light, not unknown.
+    ctx.darkMode = dark != null && /dark/i.test(dark);
+    ctx.focus = focus;
     if (ssid)
         ctx.network = ssid.split("\n")[0]?.trim() || undefined;
     const n = displays ? Number(displays) : NaN;

package/dist/providers/selfreport.js

@@ -2,7 +2,7 @@ import { readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 const STATE_FILE = join(homedir(), ".cadence", "state.txt");
-const STALE_AFTER_MS = 4 * 60 * 60 * 1000;
+export const STALE_AFTER_MS = 4 * 60 * 60 * 1000;
 export async function getSelfReportSignal() {
     try {
         const [text, info] = await Promise.all([readFile(STATE_FILE, "utf-8"), stat(STATE_FILE)]);

package/dist/signals-view.js

@@ -0,0 +1,103 @@
+import { STALE_AFTER_MS } from "./providers/selfreport.js";
+const LABEL_W = 12; // sub-row label column
+const VALUE_W = 18; // value column, before a "(hidden: …)" note
+function row(label, value, note) {
+    const v = note ? `${value.padEnd(VALUE_W)} ${note}` : value;
+    return `    ${label.padEnd(LABEL_W)}${v}`;
+}
+function top(label, value) {
+    return `  ${label.padEnd(LABEL_W + 2)}${value}`;
+}
+function ttlLeft(setAt, now) {
+    const rem = Math.max(0, STALE_AFTER_MS - (now - setAt));
+    const h = Math.floor(rem / 3_600_000);
+    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 ambientRows(a, platform) {
+    if (!a)
+        return [top("ambient", "— unavailable")];
+    const mac = platform === "darwin";
+    const macNote = "— macOS only";
+    const lines = ["  ambient"];
+    lines.push(row("time", `${a.partOfDay} (${a.dayOfWeek})`));
+    lines.push(row("weather", a.weather ?? "— off (run: cadence set-location <lat> <lon>)"));
+    lines.push(!mac
+        ? row("battery", macNote)
+        : a.onBattery == null
+            ? row("battery", "— unavailable")
+            : a.onBattery
+                ? row("battery", `unplugged${a.batteryPct != null ? `, ${a.batteryPct}%` : ""}`)
+                : row("battery", `plugged in${a.batteryPct != null ? `, ${a.batteryPct}%` : ""}`, "(hidden: only shows unplugged)"));
+    lines.push(!mac
+        ? row("dark mode", macNote)
+        : a.darkMode == null
+            ? row("dark mode", "— unavailable")
+            : a.darkMode
+                ? row("dark mode", "on")
+                : row("dark mode", "off", "(hidden: only shows on)"));
+    lines.push(!mac
+        ? row("displays", macNote)
+        : a.displays == null
+            ? row("displays", "— unavailable")
+            : a.displays > 1
+                ? row("displays", String(a.displays))
+                : 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"));
+    lines.push(a.uptimeHours == null
+        ? row("uptime", "— unavailable")
+        : a.uptimeHours >= 12
+            ? row("uptime", `${a.uptimeHours}h`)
+            : row("uptime", `${a.uptimeHours}h`, "(hidden: only shows ≥12h)"));
+    lines.push(a.loadHigh
+        ? row("load", "high (machine busy)")
+        : row("load", "normal", "(hidden: only shows high)"));
+    lines.push(!mac
+        ? row("focus", macNote)
+        : a.focus == null
+            ? row("focus", "— unavailable (terminal needs Full Disk Access)")
+            : a.focus
+                ? row("focus", "on")
+                : row("focus", "off", "(hidden: only shows on)"));
+    return lines;
+}
+function musicRows(m) {
+    if (!m?.track)
+        return [top("music", "— nothing playing")];
+    const lines = ["  music"];
+    lines.push(row("track", `${JSON.stringify(m.track)}${m.artist ? ` — ${m.artist}` : ""}${m.player ? ` (${m.player})` : ""}`));
+    lines.push(m.vibe ? row("vibe", m.vibe) : row("vibe", "— no tags yet (looked up once per artist)"));
+    return lines;
+}
+function reportRow(r, now) {
+    if (!r)
+        return top("self_report", '— none set (run: cadence state "...")');
+    const text = r.text.length > 44 ? `${r.text.slice(0, 43)}…` : r.text;
+    return top("self_report", `${JSON.stringify(text)} (${ttlLeft(r.setAt, now)})`);
+}
+function gitRow(g) {
+    if (!g)
+        return top("git", "— not a git repo (signal is per-directory)");
+    const parts = [
+        g.commitsLastHour > 0
+            ? `${g.commitsLastHour} commit${g.commitsLastHour === 1 ? "" : "s"}/hr`
+            : null,
+        g.filesDirty > 0 ? `${g.filesDirty} dirty` : "clean tree",
+        g.minSinceLastCommit != null ? `last commit ${g.minSinceLastCommit}m ago` : null,
+        g.conflicted ? "mid-conflict" : null,
+    ].filter(Boolean);
+    return top("git", parts.join(", "));
+}
+export function renderSignalsTable(raw) {
+    return [
+        ...ambientRows(raw.ambient, raw.platform),
+        ...musicRows(raw.music),
+        reportRow(raw.report, raw.now),
+        gitRow(raw.git),
+        top("activity", "— session-only (the hook injects it per-prompt)"),
+    ].join("\n");
+}

package/dist/vibe.js

@@ -37,11 +37,55 @@ const GENRE_AFFECT = {
     pop: { energy: 0.72, valence: 0.78, acoustic: 0.15, moods: ["happy", "uplifting"] },
     funk: { energy: 0.75, valence: 0.8, acoustic: 0.1, moods: ["happy", "energetic"] },
     disco: { energy: 0.8, valence: 0.85, acoustic: 0.1, moods: ["happy", "uplifting"] },
+    "post-hardcore": { energy: 0.85, valence: 0.45, acoustic: 0.05, moods: ["aggressive", "energetic"] },
+    "post-punk": { energy: 0.7, valence: 0.4, acoustic: 0.1, moods: ["dark", "energetic"] },
+    screamo: { energy: 0.9, valence: 0.3, acoustic: 0.03, moods: ["aggressive", "dark"] },
+    grindcore: { energy: 0.98, valence: 0.3, acoustic: 0.02, moods: ["aggressive", "scary"] },
+    grunge: { energy: 0.75, valence: 0.4, acoustic: 0.15, moods: ["aggressive", "dark"] },
+    emo: { energy: 0.7, valence: 0.35, acoustic: 0.2, moods: ["sad", "energetic"] },
+    stoner: { energy: 0.7, valence: 0.5, acoustic: 0.15, moods: ["dark", "energetic"] },
+    sludge: { energy: 0.65, valence: 0.25, acoustic: 0.1, moods: ["dark", "aggressive"] },
+    industrial: { energy: 0.8, valence: 0.35, acoustic: 0.02, moods: ["dark", "aggressive"] },
+    noise: { energy: 0.7, valence: 0.25, acoustic: 0.05, moods: ["scary", "aggressive"] },
+    trance: { energy: 0.85, valence: 0.65, acoustic: 0.02, moods: ["energetic", "uplifting"] },
+    dubstep: { energy: 0.85, valence: 0.5, acoustic: 0.02, moods: ["energetic", "dark"] },
+    edm: { energy: 0.85, valence: 0.7, acoustic: 0.02, moods: ["energetic", "uplifting"] },
+    trap: { energy: 0.75, valence: 0.5, acoustic: 0.05, moods: ["energetic", "dark"] },
+    drill: { energy: 0.75, valence: 0.4, acoustic: 0.05, moods: ["dark", "aggressive"] },
+    grime: { energy: 0.8, valence: 0.5, acoustic: 0.05, moods: ["aggressive", "energetic"] },
+    "k-pop": { energy: 0.8, valence: 0.8, acoustic: 0.08, moods: ["happy", "energetic"] },
+    "j-pop": { energy: 0.78, valence: 0.8, acoustic: 0.1, moods: ["happy", "uplifting"] },
+    "new wave": { energy: 0.7, valence: 0.65, acoustic: 0.08, moods: ["energetic", "happy"] },
+    synthpop: { energy: 0.7, valence: 0.7, acoustic: 0.05, moods: ["happy", "energetic"] },
+    "synth-pop": { energy: 0.7, valence: 0.7, acoustic: 0.05, moods: ["happy", "energetic"] },
+    reggaeton: { energy: 0.8, valence: 0.75, acoustic: 0.05, moods: ["sexy", "energetic"] },
+    latin: { energy: 0.75, valence: 0.75, acoustic: 0.3, moods: ["happy", "energetic"] },
+    salsa: { energy: 0.8, valence: 0.8, acoustic: 0.4, moods: ["happy", "energetic"] },
+    cumbia: { energy: 0.65, valence: 0.75, acoustic: 0.4, moods: ["happy"] },
+    afrobeat: { energy: 0.75, valence: 0.75, acoustic: 0.3, moods: ["happy", "energetic"] },
+    ska: { energy: 0.8, valence: 0.75, acoustic: 0.15, moods: ["happy", "energetic"] },
+    surf: { energy: 0.7, valence: 0.7, acoustic: 0.2, moods: ["happy", "energetic"] },
+    "math rock": { energy: 0.75, valence: 0.55, acoustic: 0.2, moods: ["energetic"] },
     // ── mid / groovy → ship-or-think depending on energy ─────────────────
     "r&b": { energy: 0.55, valence: 0.6, acoustic: 0.2, moods: ["sexy", "chilled"] },
     soul: { energy: 0.55, valence: 0.65, acoustic: 0.25, moods: ["romantic", "uplifting"] },
     reggae: { energy: 0.6, valence: 0.75, acoustic: 0.2, moods: ["chilled", "happy"] },
     indie: { energy: 0.6, valence: 0.55, acoustic: 0.3, moods: ["chilled"] },
+    alternative: { energy: 0.65, valence: 0.5, acoustic: 0.2, moods: ["energetic"] },
+    progressive: { energy: 0.65, valence: 0.5, acoustic: 0.15, moods: ["epic"] },
+    psychedelic: { energy: 0.6, valence: 0.55, acoustic: 0.3, moods: ["ethereal"] },
+    krautrock: { energy: 0.6, valence: 0.5, acoustic: 0.2, moods: ["ethereal", "energetic"] },
+    synthwave: { energy: 0.65, valence: 0.55, acoustic: 0.02, moods: ["energetic", "ethereal"] },
+    "city pop": { energy: 0.6, valence: 0.7, acoustic: 0.3, moods: ["happy", "chilled"] },
+    garage: { energy: 0.75, valence: 0.6, acoustic: 0.1, moods: ["energetic"] },
+    country: { energy: 0.55, valence: 0.6, acoustic: 0.7, moods: ["happy", "romantic"] },
+    bluegrass: { energy: 0.65, valence: 0.7, acoustic: 0.9, moods: ["happy", "uplifting"] },
+    americana: { energy: 0.45, valence: 0.5, acoustic: 0.8, moods: ["calm", "romantic"] },
+    gospel: { energy: 0.6, valence: 0.8, acoustic: 0.6, moods: ["uplifting", "epic"] },
+    swing: { energy: 0.65, valence: 0.75, acoustic: 0.6, moods: ["happy"] },
+    "big band": { energy: 0.65, valence: 0.7, acoustic: 0.6, moods: ["happy", "epic"] },
+    samba: { energy: 0.7, valence: 0.8, acoustic: 0.5, moods: ["happy"] },
+    flamenco: { energy: 0.6, valence: 0.5, acoustic: 0.85, moods: ["romantic", "epic"] },
     // ── low energy, organic → think ──────────────────────────────────────
     ambient: { energy: 0.2, valence: 0.5, acoustic: 0.6, moods: ["ethereal", "calm"] },
     "lo-fi": { energy: 0.3, valence: 0.5, acoustic: 0.4, moods: ["chilled", "calm"] },
@@ -59,23 +103,41 @@ const GENRE_AFFECT = {
     "singer-songwriter": { energy: 0.4, valence: 0.5, acoustic: 0.7, moods: ["calm", "sad"] },
     "post-rock": { energy: 0.5, valence: 0.4, acoustic: 0.4, moods: ["epic", "ethereal"] },
     shoegaze: { energy: 0.55, valence: 0.4, acoustic: 0.3, moods: ["ethereal", "dark"] },
+    "dream pop": { energy: 0.45, valence: 0.5, acoustic: 0.3, moods: ["ethereal", "chilled"] },
+    "bedroom pop": { energy: 0.45, valence: 0.55, acoustic: 0.3, moods: ["chilled"] },
+    vaporwave: { energy: 0.35, valence: 0.45, acoustic: 0.1, moods: ["ethereal", "chilled"] },
+    idm: { energy: 0.55, valence: 0.45, acoustic: 0.05, moods: ["ethereal"] },
+    "bossa nova": { energy: 0.35, valence: 0.6, acoustic: 0.7, moods: ["chilled", "romantic"] },
+    "new age": { energy: 0.2, valence: 0.6, acoustic: 0.7, moods: ["calm", "ethereal"] },
+    soundtrack: { energy: 0.45, valence: 0.45, acoustic: 0.6, moods: ["epic"] },
+    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 → debug-leaning ──────────────────────────
     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"] },
+    darkwave: { energy: 0.6, valence: 0.35, acoustic: 0.1, moods: ["dark", "ethereal"] },
+    drone: { energy: 0.15, valence: 0.3, acoustic: 0.4, moods: ["dark", "ethereal"] },
     slowcore: { energy: 0.25, valence: 0.3, acoustic: 0.5, moods: ["sad", "dark"] },
     sad: { energy: 0.3, valence: 0.2, acoustic: 0.5, moods: ["sad"] },
     melancholy: { energy: 0.3, valence: 0.25, acoustic: 0.5, moods: ["sad", "dark"] },
     melancholic: { energy: 0.3, valence: 0.25, acoustic: 0.5, moods: ["sad", "dark"] },
     doom: { energy: 0.5, valence: 0.2, acoustic: 0.2, moods: ["dark", "scary"] },
 };
+// Keys sorted longest-first so the most SPECIFIC row wins per tag: a
+// "post-rock" tag must hit the post-rock row, never fall through to "rock".
+// (Insertion-order matching silently mis-filed every sub-genre whose parent
+// appeared earlier in the table.)
+const GENRE_KEYS = Object.keys(GENRE_AFFECT).sort((a, b) => b.length - a.length);
 /** Match a list of raw tags against the affect table and aggregate. */
 export function tagsToVibe(tags) {
     const hits = [];
     for (const raw of tags) {
         const t = raw.toLowerCase();
-        for (const key in GENRE_AFFECT) {
+        for (const key of GENRE_KEYS) {
             if (t.includes(key)) {
                 hits.push(GENRE_AFFECT[key]);
-                break; // one row per tag — don't double-count "trip hop" as "hop"
+                break; // one row per tag — the longest (most specific) match wins
             }
         }
     }

package/hooks/hooks.json

@@ -22,6 +22,17 @@
         ]
       }
     ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/dist/posttool.js\""
+          }
+        ]
+      }
+    ],
     "Stop": [
       {
         "matcher": "",

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@cullumco/cadence",
-  "version": "0.1.1",
-  "description": "Agents that read the room. Ambient context, cadence dials, and finish-line guardrails for Claude Code.",
+  "version": "0.1.3",
+  "description": "Agents that read the room. Ambient context, cadence dials, and finish-line guardrails for Claude Code. macOS-only alpha.",
   "type": "module",
   "bin": {
     "cadence": "bin/cadence"
   },
-  "homepage": "https://github.com/cullumco/cadence",
+  "homepage": "https://cullumco.github.io/cadence/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cullumco/cadence.git"