@cullumco/cadence 0.1.1 → 0.1.2

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.2",
+  "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,6 +9,9 @@ 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.
 
+**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.
 
 ## 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
@@ -69,9 +96,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 +143,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 +219,26 @@ 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*.
+- **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?).
+  - **scheduled Focus** — manual Focus detection ships now; scheduled/geofenced
+    Focus needs schedule math against `ModeConfigurations.json`.
 - **After-the-fact injection** — refine the cadence mid-task (`PostToolUse`),
   building on the conservative finish-line `Stop` guard that now ships.
 - **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

@@ -96,6 +96,7 @@ export function deriveCadence(state) {
     // Candidate nudges, deliberately dormant until we've watched real output:
     //   conflicted → proactivity low (verify, don't barrel)
     //   commitsLastHour >= 3 → pace high (flow state)
+    //   ambient focus on → proactivity high (heads-down = fewer check-ins)
     // See BACKLOG: turn these on once the flavor proves trustworthy.
     void git;
     // ── activity → pace (returning from a break = slow back down) ─────────────

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/providers/ambient.js

@@ -22,6 +22,7 @@ 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_ASSERTIONS = join(homedir(), "Library", "DoNotDisturb", "DB", "Assertions.json");
 const WEATHER_TIMEOUT_MS = 900;
 const DAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 function partOfDay(hour) {
@@ -62,19 +63,44 @@ function getVitals() {
     const load1 = loadavg()[0] ?? 0;
     return { uptimeHours, loadHigh: load1 / cores > 0.8 };
 }
+// 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 (manually toggled on this device)
+//   false     → file read OK, no assertion records → focus is 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"
+// Known gap: SCHEDULED/geofenced Focus writes no assertion record (detecting
+// it needs ModeConfigurations.json schedule math — backlogged).
+export async function getFocus() {
+    if (process.platform !== "darwin")
+        return undefined;
+    try {
+        const raw = await readFile(DND_ASSERTIONS, "utf-8");
+        const json = JSON.parse(raw);
+        const records = json.data?.[0]?.storeAssertionRecords;
+        return Array.isArray(records) && records.length > 0;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ── 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/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.2",
+  "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"