@cullumco/cadence 0.1.2 → 0.1.4

package/.claude-plugin/plugin.json

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

package/README.md

@@ -12,7 +12,7 @@ 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.
+A [Cullum&Co](https://cullum.co) project · [cullumco.github.io/cadence](https://cullumco.github.io/cadence/)
 
 ## What it does
 
@@ -21,8 +21,8 @@ Before Claude sees your prompt, Cadence injects a `<user_state>` block:
 ```
 <user_state>
   signals:
-    music: "Loose" — Daniel Caesar (Spotify)
-    vibe: sexy, chilled
+    music: "You Fail Me" — Converge (Spotify)
+    vibe: aggressive, energetic
     self_report: "two beers, shipping"
   cadence:  # inferred from signals, advisory
     { pace=fast tone=warm posture=decisive proactivity=act-freely }
@@ -78,8 +78,10 @@ Same words. The room around them changed, and the agent finally saw it.
      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
@@ -228,10 +230,12 @@ See [`BACKLOG.md`](BACKLOG.md). Highlights:
     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.
+  - **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

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,13 +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)
+    // Still-dormant candidate nudges (see BACKLOG):
     //   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) ─────────────
     if (activity?.minSinceLastPrompt != null && activity.minSinceLastPrompt > 30) {
         c.pace = "low";

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,7 +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_ASSERTIONS = join(homedir(), "Library", "DoNotDisturb", "DB", "Assertions.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) {
@@ -63,27 +65,78 @@ 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 (manually toggled on this device)
-//   false     → file read OK, no assertion records → focus is off
+//   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"
-// Known gap: SCHEDULED/geofenced Focus writes no assertion record (detecting
-// it needs ModeConfigurations.json schedule math — backlogged).
-export async function getFocus() {
+// 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;
-        return Array.isArray(records) && records.length > 0;
+        manual = Array.isArray(records) && records.length > 0;
     }
     catch {
-        return undefined;
+        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() {

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,6 +1,6 @@
 {
   "name": "@cullumco/cadence",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Agents that read the room. Ambient context, cadence dials, and finish-line guardrails for Claude Code. macOS-only alpha.",
   "type": "module",
   "bin": {