@cullumco/cadence 0.1.0

package/dist/cli.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import { writeFile, mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getMusicSignal } from "./providers/music.js";
+import { getSelfReportSignal } from "./providers/selfreport.js";
+import { getAmbientSignal } from "./providers/ambient.js";
+import { getGitSignal } from "./providers/git.js";
+import { deriveCadence, buildReframe, loadOverrides, applyOverrides, resolveDialLevel, DIALS, DIAL_WORDS, } from "./cadence.js";
+import { render } from "./inject.js";
+const CADENCE_DIR = join(homedir(), ".cadence");
+const STATE_FILE = join(CADENCE_DIR, "state.txt");
+const CONFIG_FILE = join(CADENCE_DIR, "config.json");
+async function cmdState(args) {
+    if (args.length === 0) {
+        try {
+            const text = (await readFile(STATE_FILE, "utf-8")).trim();
+            console.log(text || "(no state set)");
+        }
+        catch {
+            console.log("(no state set)");
+        }
+        return;
+    }
+    const text = args.join(" ");
+    await mkdir(CADENCE_DIR, { recursive: true });
+    await writeFile(STATE_FILE, text, "utf-8");
+    console.log(`  state set: "${text}"`);
+}
+async function cmdClear() {
+    await mkdir(CADENCE_DIR, { recursive: true });
+    await writeFile(STATE_FILE, "", "utf-8");
+    console.log("  state cleared");
+}
+async function cmdTest() {
+    const signals = [];
+    const [music, report, ambient, git, overrides] = await Promise.all([
+        getMusicSignal().catch(() => null),
+        getSelfReportSignal().catch(() => null),
+        getAmbientSignal(new Date()).catch(() => null),
+        getGitSignal(process.cwd()).catch(() => null),
+        loadOverrides(),
+    ]);
+    if (music)
+        signals.push(music);
+    if (report)
+        signals.push(report);
+    if (ambient)
+        signals.push(ambient);
+    if (git)
+        signals.push(git);
+    if (signals.length === 0 && Object.keys(overrides).length === 0) {
+        console.log('  (no signals — play something, set: cadence state "...", or pin a dial: cadence set pace fast)');
+        return;
+    }
+    const state = { signals, capturedAt: Date.now() };
+    const { cadence, pinned } = applyOverrides(deriveCadence(state), overrides);
+    const reframe = buildReframe(cadence);
+    console.log("\n" + render({ ...state, cadence, pinned, reframe }) + "\n");
+}
+const LEVELS = ["low", "medium", "high"];
+async function cmdSet(args) {
+    const [dial, value] = args;
+    if (!dial || !value) {
+        console.log("  usage: cadence set <dial> <value>   e.g. cadence set pace fast");
+        console.log(`  dials: ${DIALS.join(", ")}`);
+        return;
+    }
+    if (!DIALS.includes(dial)) {
+        console.error(`  unknown dial "${dial}" — choose from: ${DIALS.join(", ")}`);
+        process.exit(1);
+    }
+    const d = dial;
+    const level = resolveDialLevel(d, value);
+    if (!level) {
+        const words = LEVELS.map((l) => DIAL_WORDS[d][l]).join(" | ");
+        console.error(`  "${value}" isn't valid for ${dial}. Use: ${words}  (or low|medium|high)`);
+        process.exit(1);
+    }
+    await mkdir(CADENCE_DIR, { recursive: true });
+    let cfg = {};
+    try {
+        cfg = JSON.parse(await readFile(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        // no config yet
+    }
+    cfg[dial] = level;
+    await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
+    console.log(`  pinned ${dial} = ${DIAL_WORDS[d][level]} (${level})`);
+}
+async function cmdUnset(args) {
+    const [dial] = args;
+    await mkdir(CADENCE_DIR, { recursive: true });
+    let cfg = {};
+    try {
+        cfg = JSON.parse(await readFile(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        // none
+    }
+    if (!dial || dial === "all") {
+        await writeFile(CONFIG_FILE, "{}", "utf-8");
+        console.log("  unpinned all dials — back to fully inferred");
+        return;
+    }
+    delete cfg[dial];
+    await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
+    console.log(`  unpinned ${dial} — back to inferred`);
+}
+async function cmdDials() {
+    const overrides = await loadOverrides();
+    console.log("\n  cadence dials (* = pinned by you):\n");
+    for (const dial of DIALS) {
+        const pinnedLevel = overrides[dial];
+        const opts = LEVELS.map((l) => {
+            const word = DIAL_WORDS[dial][l];
+            return l === pinnedLevel ? `[${word}]*` : word;
+        }).join("  ");
+        console.log(`    ${dial.padEnd(12)} ${opts}`);
+    }
+    console.log("\n  pin one:  cadence set <dial> <low|medium|high>");
+    console.log("  unpin:    cadence unset <dial>   (or: cadence unset all)\n");
+}
+// Weather is opt-in: it only activates once a location is configured. No
+// silent geolocation — the user provides coordinates explicitly.
+async function cmdLocation(args) {
+    const [lat, lon, ...nameParts] = args;
+    if (!lat || !lon) {
+        console.log("  usage: cadence set-location <lat> <lon> [name]");
+        console.log("  e.g.   cadence set-location 40.71 -74.01 NYC");
+        console.log("  (find yours at https://www.latlong.net — weather stays off until set)");
+        return;
+    }
+    const latNum = Number(lat);
+    const lonNum = Number(lon);
+    if (!Number.isFinite(latNum) || !Number.isFinite(lonNum)) {
+        console.error("  lat and lon must be numbers");
+        process.exit(1);
+    }
+    await mkdir(CADENCE_DIR, { recursive: true });
+    let cfg = {};
+    try {
+        cfg = JSON.parse(await readFile(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        // none
+    }
+    cfg["location"] = { lat: latNum, lon: lonNum, name: nameParts.join(" ") || undefined };
+    await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
+    console.log(`  location set${nameParts.length ? ` (${nameParts.join(" ")})` : ""} — weather is now on`);
+}
+const HELP = `
+  cadence — agents that read the room
+
+  daily:
+    cadence state "..."         set self-reported state (e.g. "two beers, ship mode")
+    cadence state               print current self-reported state
+    cadence clear               clear self-reported state
+    cadence test                preview what the hook would inject right now
+
+  dials (your determination — pinned dials override inference):
+    cadence dials               show the mixing board and what's pinned
+    cadence set <dial> <level>  pin a dial (level: low|medium|high)
+    cadence unset <dial>        un-pin a dial (or: cadence unset all)
+                                dials: pace, tone, posture, proactivity
+                                (env also works: CADENCE_PACE=fast)
+
+  ambient (time & day are automatic; weather is opt-in):
+    cadence set-location <lat> <lon> [name]   turn on weather for your area
+`;
+async function main() {
+    const [cmd, ...rest] = process.argv.slice(2);
+    switch (cmd) {
+        case "state":
+            return cmdState(rest);
+        case "clear":
+            return cmdClear();
+        case "test":
+            return cmdTest();
+        case "set":
+            return cmdSet(rest);
+        case "unset":
+            return cmdUnset(rest);
+        case "dials":
+            return cmdDials();
+        case "set-location":
+            return cmdLocation(rest);
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(HELP);
+            return;
+        default:
+            console.error(`unknown command: ${cmd}`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`error: ${msg}`);
+    process.exit(1);
+});

package/dist/hook.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { getMusicSignal } from "./providers/music.js";
+import { getSelfReportSignal } from "./providers/selfreport.js";
+import { getAmbientSignal } from "./providers/ambient.js";
+import { getGitSignal } from "./providers/git.js";
+import { getActivitySignal } from "./providers/activity.js";
+import { deriveCadence, buildReframe, loadOverrides, applyOverrides } from "./cadence.js";
+import { render } from "./inject.js";
+const TOTAL_BUDGET_MS = 1500;
+// Claude Code alpha adapter: collect portable Cadence signals, derive the core
+// cadence state, then deliver it through UserPromptSubmit.additionalContext.
+// Keep Claude-specific payload/output details here so the core stays reusable.
+// Claude Code writes a JSON payload to stdin; it includes `cwd` (the project
+// dir). We read it so the git provider inspects the RIGHT repo, not wherever
+// the hook binary happens to live.
+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 collectSignals(cwd, prompt) {
+    const [music, report, ambient, git, activity] = await Promise.allSettled([
+        getMusicSignal(),
+        getSelfReportSignal(),
+        getAmbientSignal(new Date()),
+        getGitSignal(cwd),
+        getActivitySignal(prompt),
+    ]);
+    const signals = [];
+    if (music.status === "fulfilled" && music.value)
+        signals.push(music.value);
+    if (report.status === "fulfilled" && report.value)
+        signals.push(report.value);
+    if (ambient.status === "fulfilled" && ambient.value)
+        signals.push(ambient.value);
+    if (git.status === "fulfilled" && git.value)
+        signals.push(git.value);
+    if (activity.status === "fulfilled" && activity.value)
+        signals.push(activity.value);
+    return signals;
+}
+async function main() {
+    const { cwd, prompt } = await readStdin();
+    const projectDir = cwd ?? process.cwd();
+    const [signals, overrides] = await Promise.all([
+        Promise.race([
+            collectSignals(projectDir, prompt),
+            new Promise((resolve) => setTimeout(() => resolve([]), TOTAL_BUDGET_MS)),
+        ]),
+        loadOverrides(),
+    ]);
+    // Nothing to say: no signals AND no pinned dials.
+    if (signals.length === 0 && Object.keys(overrides).length === 0) {
+        process.exit(0);
+    }
+    const state = { signals, capturedAt: Date.now() };
+    const { cadence, pinned } = applyOverrides(deriveCadence(state), overrides);
+    const reframe = buildReframe(cadence);
+    const stateWithCadence = { ...state, cadence, pinned, reframe };
+    const block = render(stateWithCadence);
+    process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: block,
+        },
+    }));
+}
+main().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`cadence: ${msg}\n`);
+    process.exit(0);
+});

package/dist/inject.js

@@ -0,0 +1,106 @@
+import { DIAL_WORDS } from "./cadence.js";
+function quote(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003c")
+        .replace(/>/g, "\\u003e")
+        .replace(/&/g, "\\u0026");
+}
+function renderMusic(m) {
+    if (!m.track)
+        return [];
+    const lines = [
+        `    music: ${quote(m.track)}${m.artist ? ` — ${quote(m.artist)}` : ""}${m.player ? ` (${quote(m.player)})` : ""}`,
+    ];
+    if (m.vibe)
+        lines.push(`    vibe: ${m.vibe}`);
+    return lines;
+}
+function renderReport(r) {
+    return `    self_report: ${quote(r.text)}`;
+}
+function renderGit(g) {
+    // Human-readable work-state, e.g. "3 commits/hr, 5 dirty, mid-merge"
+    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 `    git: ${parts.join(", ")}`;
+}
+function renderActivity(a) {
+    const parts = [
+        a.minSinceLastPrompt != null ? `min_since_prompt=${a.minSinceLastPrompt}` : null,
+        a.promptLength != null ? `prompt_len=${a.promptLength}` : null,
+    ].filter(Boolean);
+    return `    activity: { ${parts.join(" ")} }`;
+}
+function renderPlace(p) {
+    const parts = [
+        p.network ? `network=${quote(p.network)}` : null,
+        p.displays != null ? `displays=${p.displays}` : null,
+    ].filter(Boolean);
+    return `    place: { ${parts.join(" ")} }`;
+}
+function renderAmbient(a) {
+    // Human-readable atmosphere line, e.g.
+    //   "friday late night, rainy, unplugged 8%, dark mode, on Home-wifi, up 14h"
+    const parts = [
+        a.isWeekend ? `${a.dayOfWeek} ${a.partOfDay}` : a.partOfDay,
+        a.weather ?? null,
+        a.onBattery === true
+            ? `unplugged${a.batteryPct != null ? ` ${a.batteryPct}%` : ""}`
+            : null,
+        a.darkMode === true ? "dark mode" : null,
+        a.displays != null && a.displays > 1 ? `${a.displays} displays` : null,
+        a.network ? `on ${quote(a.network)}` : null,
+        a.loadHigh ? "machine busy" : null,
+        a.uptimeHours != null && a.uptimeHours >= 12 ? `up ${a.uptimeHours}h` : null,
+    ].filter(Boolean);
+    return `    context: ${parts.join(", ")}`;
+}
+function renderCadence(c, pinned) {
+    const dials = Object.keys(DIAL_WORDS)
+        .map((d) => {
+        const word = DIAL_WORDS[d][c[d]];
+        return pinned.includes(d) ? `${d}=${word}*` : `${d}=${word}`;
+    })
+        .join(" ");
+    return `    { ${dials} }`;
+}
+export function render(state) {
+    const lines = [];
+    for (const sig of state.signals) {
+        if (sig.source === "music")
+            lines.push(...renderMusic(sig));
+        else if (sig.source === "self_report")
+            lines.push(renderReport(sig));
+        else if (sig.source === "git")
+            lines.push(renderGit(sig));
+        else if (sig.source === "activity")
+            lines.push(renderActivity(sig));
+        else if (sig.source === "place")
+            lines.push(renderPlace(sig));
+        else if (sig.source === "ambient")
+            lines.push(renderAmbient(sig));
+    }
+    // Render even with zero signals if the user pinned dials — a hand-set board
+    // is itself a signal worth injecting.
+    if (lines.length === 0 && state.pinned.length === 0)
+        return "";
+    // Evidence (signals) leads, then the dials, then the interpretation lens
+    // composed from them. `*` marks a user-pinned dial (their determination,
+    // higher authority than inference). The reframe still defers to literal words.
+    const note = state.pinned.length
+        ? "  # * = you set it; rest inferred from signals, advisory"
+        : "  # inferred from signals, advisory";
+    return [
+        "<user_state>",
+        `  signals:`,
+        ...lines,
+        `  cadence:${note}`,
+        renderCadence(state.cadence, state.pinned),
+        `  reframe: ${state.reframe}`,
+        "</user_state>",
+    ].join("\n");
+}

package/dist/providers/activity.js

@@ -0,0 +1,35 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CADENCE_DIR = join(homedir(), ".cadence");
+const ACTIVITY_FILE = join(CADENCE_DIR, "activity.json");
+export function activityFrom(prompt, lastPromptAt, now) {
+    if (prompt == null)
+        return null;
+    const signal = {
+        source: "activity",
+        promptLength: prompt.length,
+    };
+    if (lastPromptAt != null && Number.isFinite(lastPromptAt)) {
+        signal.minSinceLastPrompt = Math.max(0, Math.round((now - lastPromptAt) / 60000));
+    }
+    return signal;
+}
+export async function getActivitySignal(prompt, now = Date.now()) {
+    let state = {};
+    try {
+        state = JSON.parse(await readFile(ACTIVITY_FILE, "utf-8"));
+    }
+    catch {
+        // no activity file yet
+    }
+    const signal = activityFrom(prompt, state.lastPromptAt, now);
+    try {
+        await mkdir(CADENCE_DIR, { recursive: true });
+        await writeFile(ACTIVITY_FILE, JSON.stringify({ lastPromptAt: now }), "utf-8");
+    }
+    catch {
+        // activity is best-effort; never let it break the hook
+    }
+    return signal;
+}

package/dist/providers/ambient.js

@@ -0,0 +1,158 @@
+import { exec } from "node:child_process";
+import { readFile } 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
+// (never throws) so a missing command can't break the hook.
+function sh(cmd, ms = 500) {
+    return new Promise((resolve) => {
+        const child = exec(cmd, { timeout: ms, windowsHide: true }, (err, out) => resolve(err ? null : out.trim()));
+        child.on("error", () => resolve(null));
+    });
+}
+/* ─────────────────────────────────────────────────────────────────────────
+ * Ambient context provider — the cheapest signals, biggest reach.
+ *
+ *   time + day  → always available, every OS, no deps, never fails. This is
+ *                 the signal that makes Cadence do something for everyone.
+ *   weather     → opt-in: only if ~/.cadence/config.json has a location.
+ *                 Keyless via Open-Meteo. No silent geolocation.
+ *   battery     → macOS pmset, best-effort.
+ *
+ * "Put the vibes back into engineering": this is the atmosphere layer.
+ * ───────────────────────────────────────────────────────────────────────── */
+const CONFIG_FILE = join(homedir(), ".cadence", "config.json");
+const WEATHER_TIMEOUT_MS = 900;
+const DAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+function partOfDay(hour) {
+    if (hour < 5)
+        return "late night";
+    if (hour < 9)
+        return "early morning";
+    if (hour < 12)
+        return "morning";
+    if (hour < 14)
+        return "midday";
+    if (hour < 18)
+        return "afternoon";
+    if (hour < 22)
+        return "evening";
+    return "late night";
+}
+async function getBattery() {
+    if (process.platform !== "darwin")
+        return {};
+    const out = await sh("pmset -g batt", 600);
+    if (!out)
+        return {};
+    const onBattery = /Battery Power/.test(out)
+        ? true
+        : /AC Power/.test(out)
+            ? false
+            : undefined;
+    const pctMatch = out.match(/(\d+)%/);
+    const pct = pctMatch ? Number(pctMatch[1]) : undefined;
+    return { onBattery, pct };
+}
+// ── machine vitals: pure Node, cross-platform, effectively free ──────────────
+function getVitals() {
+    const uptimeHours = Math.round((uptime() / 3600) * 10) / 10;
+    // 1-min load average relative to core count; >0.8/core ⇒ busy.
+    const cores = Math.max(1, cpus().length);
+    const load1 = loadavg()[0] ?? 0;
+    return { uptimeHours, loadHigh: load1 / cores > 0.8 };
+}
+// ── 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([
+        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),
+    ]);
+    const ctx = {};
+    if (dark != null)
+        ctx.darkMode = /dark/i.test(dark);
+    if (ssid)
+        ctx.network = ssid.split("\n")[0]?.trim() || undefined;
+    const n = displays ? Number(displays) : NaN;
+    if (Number.isFinite(n) && n > 0)
+        ctx.displays = n;
+    return ctx;
+}
+// WMO weather codes → a single human word. Open-Meteo returns these.
+function weatherWord(code) {
+    if (code === 0)
+        return "clear";
+    if (code <= 3)
+        return "cloudy";
+    if (code <= 48)
+        return "foggy";
+    if (code <= 67)
+        return "rainy";
+    if (code <= 77)
+        return "snowy";
+    if (code <= 82)
+        return "rainy";
+    if (code <= 86)
+        return "snowy";
+    return "stormy";
+}
+async function getWeather() {
+    let cfg;
+    try {
+        cfg = JSON.parse(await readFile(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return undefined; // no config → weather is simply off
+    }
+    const loc = cfg.location;
+    if (!loc || typeof loc.lat !== "number" || typeof loc.lon !== "number")
+        return undefined;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), WEATHER_TIMEOUT_MS);
+    try {
+        const url = `https://api.open-meteo.com/v1/forecast?latitude=${loc.lat}` +
+            `&longitude=${loc.lon}&current=weather_code`;
+        const res = await fetch(url, { signal: ctrl.signal });
+        if (!res.ok)
+            return undefined;
+        const data = (await res.json());
+        const code = data.current?.weather_code;
+        return typeof code === "number" ? weatherWord(code) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function getAmbientSignal(now) {
+    const hour = now.getHours();
+    const vitals = getVitals(); // sync, free
+    // all probes run in parallel; each resolves to a safe default on failure.
+    const [weather, battery, mac] = await Promise.all([
+        getWeather(),
+        getBattery(),
+        getMacContext(),
+    ]);
+    return {
+        source: "ambient",
+        partOfDay: partOfDay(hour),
+        dayOfWeek: DAYS[now.getDay()] ?? "",
+        isWeekend: now.getDay() === 0 || now.getDay() === 6,
+        hour,
+        weather,
+        onBattery: battery.onBattery,
+        batteryPct: battery.pct,
+        uptimeHours: vitals.uptimeHours,
+        loadHigh: vitals.loadHigh,
+        focus: mac.focus,
+        displays: mac.displays,
+        network: mac.network,
+        darkMode: mac.darkMode,
+    };
+}

package/dist/providers/git.js

@@ -0,0 +1,52 @@
+import { exec } from "node:child_process";
+/* ─────────────────────────────────────────────────────────────────────────
+ * git work-state — the honest "what are you actually doing" signal.
+ *
+ * Cross-platform (git is git everywhere). Reads the repo at `cwd` — which,
+ * when run from the hook, is the project Claude Code is working in.
+ *
+ * Rendered as flavor for now: commits this hour, dirty files, and whether
+ * you're mid-merge/rebase (the real debug tell). No dial nudges yet — we
+ * watch the output first, then decide what should steer.
+ * ───────────────────────────────────────────────────────────────────────── */
+const GIT_TIMEOUT_MS = 700;
+function git(args, cwd) {
+    return new Promise((resolve) => {
+        const child = exec(`git ${args}`, { cwd, timeout: GIT_TIMEOUT_MS, windowsHide: true }, (err, stdout) => resolve(err ? null : stdout.trim()));
+        child.on("error", () => resolve(null));
+    });
+}
+export async function getGitSignal(cwd = process.cwd()) {
+    // Bail fast if this isn't a repo — cheapest possible check.
+    const inRepo = await git("rev-parse --is-inside-work-tree", cwd);
+    if (inRepo !== "true")
+        return null;
+    const [statusOut, logOut, mergeHead, rebaseDir] = await Promise.all([
+        git("status --porcelain", cwd),
+        // commit timestamps (unix) in the last hour
+        git('log --since="1 hour ago" --format=%ct', cwd),
+        git("rev-parse --verify -q MERGE_HEAD", cwd), // non-null ⇒ mid-merge
+        git("rev-parse --git-path rebase-merge", cwd), // path exists ⇒ mid-rebase
+    ]);
+    const filesDirty = statusOut ? statusOut.split("\n").filter(Boolean).length : 0;
+    const commitsLastHour = logOut ? logOut.split("\n").filter(Boolean).length : 0;
+    // conflict markers in `status --porcelain`: UU, AA, DD, AU, UA, DU, UD
+    const conflicted = mergeHead != null ||
+        (statusOut != null && /^(UU|AA|DD|AU|UA|DU|UD) /m.test(statusOut));
+    // minutes since most recent commit, if any in the window
+    let minSinceLastCommit;
+    if (logOut) {
+        const newest = Math.max(...logOut.split("\n").filter(Boolean).map(Number));
+        if (Number.isFinite(newest)) {
+            minSinceLastCommit = Math.round((Date.now() / 1000 - newest) / 60);
+        }
+    }
+    void rebaseDir; // reserved: rebase detection refinement (see BACKLOG)
+    return {
+        source: "git",
+        commitsLastHour,
+        minSinceLastCommit,
+        filesDirty,
+        conflicted,
+    };
+}