@profoundry-us/highball 0.4.1 → 0.6.0

package/lib/init.js

@@ -8,16 +8,25 @@ import { basename, join } from "node:path";
 const CHECKS_TEMPLATE = (project) => `# ${project}'s Highball rules — the file \`highball run\` reads and
 # reports from. \`fast: true\` marks rules cheap enough to run on every
 # agent edit; the rest join at turn end. \`todo: true\` declares a rule
-# you're committed to but haven't built — tracked on the dashboard,
+# you're committed to but haven't built — tracked in run history,
 # never a failure.
 version: 1
 project: ${project}
 
-# Where runs get reported. The URL is per-team and not a secret, so it
-# lives here in committed config; the token never enters the repo — run
-# \`highball login\` once per machine (or set HIGHBALL_TOKEN in CI).
+# Set \`enabled: false\` to switch this repo's checks off for everyone,
+# without deleting rules or hooks. To switch them off only in YOUR
+# checkout, leave this alone and \`touch .highball/disabled\` instead —
+# it is gitignored, and takes effect on the next run.
+
+# Optional telemetry. The PostHog project key is write-only by design, so
+# it is committed config — there is no login step and no credentials file.
+# To keep it out of the repo instead, set HIGHBALL_POSTHOG_KEY in the
+# environment (e.g. the env block of ~/.claude/settings.json) and leave
+# this block out entirely.
 # reporting:
-#   url: https://your-highball-host
+#   posthog:
+#     host: https://us.i.posthog.com
+#     project_key: phc_your_key
 
 # If this repo's toolchain lives in a container, declare the wrapper once
 # and every rule runs through it; rules that belong on the host opt out
@@ -39,12 +48,19 @@ checks:
 // Always the SCOPED command. The unscoped npm name belongs to an unrelated
 // package, so a bare `npx highball` in a committed hook is one uninstalled
 // checkout away from fetching a stranger's code and running it on every edit.
+//
+// The fast hook matches Bash as well as the edit tools: agents in auto mode
+// edit through Bash, and a hook on Write|Edit alone never fires for them.
+// --if-changed keeps the Bash firings free when the tree hasn't moved.
 const HOOKS_JSON = {
   hooks: {
     PostToolUse: [
       {
-        matcher: "Write|Edit",
-        hooks: [{ type: "command", command: "npx @profoundry-us/highball run --fast" }]
+        matcher: "Write|Edit|Bash",
+        hooks: [{
+          type: "command",
+          command: "npx @profoundry-us/highball run --fast --if-changed"
+        }]
       }
     ],
     Stop: [
@@ -69,6 +85,18 @@ export async function init() {
     console.log(`created .highball/checks.yml (project: ${project}) — add your rules`);
   }
 
+  // Ignore the `disabled` marker from inside .highball/ rather than by
+  // editing the repo's root .gitignore, which init doesn't own. It is
+  // committed, so every clone inherits the protection and nobody has to
+  // remember the setup step that keeps a local switch-off local.
+  const ignorePath = join(root, ".highball", ".gitignore");
+  if (existsSync(ignorePath)) {
+    console.log("kept existing .highball/.gitignore");
+  } else {
+    writeFileSync(ignorePath, "# A local, uncommitted `highball run` off switch.\ndisabled\n");
+    console.log("created .highball/.gitignore (keeps the `disabled` marker out of commits)");
+  }
+
   const settingsPath = join(root, ".claude", "settings.json");
   if (existsSync(settingsPath)) {
     console.log(
@@ -82,8 +110,8 @@ export async function init() {
   }
 
   console.log(
-    "\nnext: fill in .highball/checks.yml, uncomment reporting.url, and run" +
-      "\n  highball login   # stores this machine's project token"
+    "\nnext: fill in .highball/checks.yml, and optionally uncomment the" +
+      "\nreporting.posthog block to send runs to PostHog."
   );
   return 0;
 }

package/lib/journal.js

@@ -1,9 +1,9 @@
 // The local run journal: every run appends one JSONL line to
 // ~/.highball/runs/<project>.jsonl, whether or not remote reporting is
-// configured. This is what makes the runner useful with no dashboard at
-// all — `highball runs` reads it — and it lives outside the repo tree
-// (like credentials) so there's no gitignore to manage and no state to
-// leak into commits.
+// configured. This is what makes the runner useful with no telemetry at
+// all — `highball runs` and the MCP widget read it — and it lives outside
+// the repo tree so there's no gitignore to manage and no state to leak
+// into commits.
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";

package/lib/mcp.js

@@ -21,34 +21,61 @@ const VERSION = JSON.parse(
   readFileSync(new URL("../package.json", import.meta.url), "utf8")
 ).version;
 
-// The server may be launched from a repo (project inferable) or from a
-// host like Claude Desktop whose cwd is nowhere useful. Resolution order:
-// explicit argument, the cwd's checks.yml, then the journal with the
-// newest run — the repo being actively worked in IS the current project.
-// Journal records carry the repo dir (since runs record process.cwd()),
-// so every path out of here can ground the widget's re-run buttons.
-function resolveProject(explicit) {
-  if (explicit) return { project: explicit, dir: latestDirFor(explicit) };
+// The host decides the server's working directory, and real hosts give it
+// nothing useful — Claude Desktop and Claude Code both spawn it at `/`. So
+// "the current repo" has to arrive some other way: an explicit `project`
+// or `dir` argument, a checks.yml at cwd, or the client's MCP roots.
+// Nothing else is guessed. In particular the journal is NOT a fallback:
+// "whichever project ran most recently on this machine" is usually some
+// other repo, and a widget that silently shows another project's runs
+// reads as this project's. Unresolved means the widget offers a picker.
+//
+// Journal records carry the repo dir (runs record process.cwd()), so an
+// explicit project still grounds the widget's re-run buttons. The loaded
+// config rides along so per-repo settings (runs_limit) can apply.
+export function resolveProject({
+  project, dir, cwd = process.cwd(), roots = [], journalDir
+} = {}) {
+  if (project) {
+    const home = dir ?? latestDirFor(project, journalDir);
+    return { project, dir: home, config: tryLoad(home) };
+  }
+  for (const candidate of [ dir, cwd, ...roots ].filter(Boolean)) {
+    const config = tryLoad(candidate);
+    if (config) return { project: config.project, dir: candidate, config };
+  }
+  return { project: null, dir: null, config: null };
+}
+
+function tryLoad(root) {
+  if (!root) return null;
   try {
-    return { project: loadConfig().project, dir: process.cwd() };
+    return loadConfig(root);
   } catch {
-    let current = null;
-    for (const project of journaledProjects()) {
-      const newest = readRuns(project)[0];
-      if (!newest) continue;
-      if (!current || newest.started_at > current.started_at) {
-        current = { project, started_at: newest.started_at };
-      }
-    }
-    if (!current) return { project: null, dir: null };
-    return { project: current.project, dir: latestDirFor(current.project) };
+    return null;
   }
 }
 
 // Newest journal record that knows its repo dir (older records predate
 // the field).
-function latestDirFor(project) {
-  return readRuns(project).find((run) => run.dir)?.dir ?? null;
+function latestDirFor(project, journalDir) {
+  return readRuns(project, journalDir).find((run) => run.dir)?.dir ?? null;
+}
+
+// How many runs list_runs returns. 200 journaled runs is a fine history and
+// a terrible tool result — the structured payload alone reaches ~300KB,
+// which text-only hosts hand straight to the model. Resolution: the call's
+// `limit`, then HIGHBALL_RUNS_LIMIT, then `runs_limit:` in checks.yml (only
+// present when the project resolved through a repo), then the default.
+export const DEFAULT_RUNS_LIMIT = 25;
+
+export function resolveRunsLimit({ limit, env = process.env, config } = {}) {
+  for (const candidate of [ limit, env.HIGHBALL_RUNS_LIMIT, config?.runs_limit ]) {
+    if (candidate == null || candidate === "") continue;
+    const n = Number(candidate);
+    if (Number.isInteger(n) && n > 0) return n;
+  }
+  return DEFAULT_RUNS_LIMIT;
 }
 
 // List payloads stay lean — output tails ride only on get_run.
@@ -82,8 +109,12 @@ function reply(text, structuredContent) {
 const glyphFor = (status) =>
   status === "passed" ? "✓" : status === "todo" ? "•" : "✗";
 
-export function listText(project, runs) {
+export function listText(project, runs, total = runs.length) {
   if (runs.length === 0) return `No runs recorded for ${project} yet.`;
+  const scope = total > runs.length
+    ? `, last ${runs.length} of ${total} — raise with limit, HIGHBALL_RUNS_LIMIT, ` +
+      "or runs_limit in checks.yml"
+    : "";
   const rows = runs.map((run) => [
     `#${run.index}`,
     run.status === "passed" ? "✓ passed" : "✗ FAILED",
@@ -95,7 +126,7 @@ export function listText(project, runs) {
   ]);
   const widths = rows[0].map((_, col) =>
     Math.max(...rows.map((row) => row[col].length)));
-  const lines = [ `Runs for ${project} (newest first):` ];
+  const lines = [ `Runs for ${project} (newest first${scope}):` ];
   let lastGroup;
   runs.forEach((run, i) => {
     // Group header whenever the work (or its session) changes between
@@ -139,31 +170,68 @@ export async function mcp() {
       (!capability.mimeTypes || capability.mimeTypes.includes(RESOURCE_MIME_TYPE));
   };
 
+  // The client's MCP roots are the one thing a host can tell us about
+  // which repo is open. Best-effort: only asked of clients that advertise
+  // the capability, and a slow or failing answer resolves to nothing.
+  const clientRoots = async () => {
+    try {
+      if (!server.server.getClientCapabilities()?.roots) return [];
+      const { roots } = await server.server.listRoots(undefined, { timeout: 3000 });
+      return roots
+        .map((root) => root.uri)
+        .filter((uri) => uri.startsWith("file:"))
+        .map((uri) => fileURLToPath(uri));
+    } catch {
+      return [];
+    }
+  };
+
+  const projectArg = z.string().optional().describe(
+    "Project slug. Defaults to the repo at `dir`, at the server's cwd, or " +
+    "at the client's MCP roots; when none has a .highball/checks.yml the " +
+    "result lists journaled projects to choose from instead of guessing."
+  );
+  const dirArg = z.string().optional().describe(
+    "Repo root containing .highball/checks.yml. Pass the current working " +
+    "directory when calling from inside a repo."
+  );
+
   registerAppTool(server, "list_runs", {
     title: "Highball runs",
     description:
       "Recent Highball check runs for a project, from the machine-local " +
-      "journal (~/.highball/runs). Renders the runs dashboard widget.",
+      `journal (~/.highball/runs). Newest ${DEFAULT_RUNS_LIMIT} by default. ` +
+      "Renders the runs dashboard widget.",
     inputSchema: {
-      project: z.string().optional()
-        .describe("Project slug; defaults to the current repo's project")
+      project: projectArg,
+      dir: dirArg,
+      limit: z.number().int().min(1).optional().describe(
+        `Max runs to return, newest first (default ${DEFAULT_RUNS_LIMIT}; ` +
+        "HIGHBALL_RUNS_LIMIT or runs_limit in checks.yml also override)"
+      )
     },
     _meta: { ui: { resourceUri: DASHBOARD_URI } }
-  }, async ({ project: explicit }) => {
-    const { project, dir } = resolveProject(explicit);
+  }, async ({ project: explicit, dir: explicitDir, limit }) => {
+    const { project, dir, config } =
+      resolveProject({ project: explicit, dir: explicitDir, roots: await clientRoots() });
     if (!project) {
       const known = journaledProjects();
       return reply(
-        `No project resolved. Journaled projects: ${known.join(", ") || "(none)"}`,
+        "No project resolved: no .highball/checks.yml at the working " +
+          "directory or the client's roots. Pass `project` or `dir`. " +
+          `Journaled projects: ${known.join(", ") || "(none)"}`,
         { projects: known }
       );
     }
-    const runs = readRuns(project).map(summarize);
+    const history = readRuns(project);
+    const max = resolveRunsLimit({ limit, config });
+    const runs = history.slice(0, max).map(summarize);
     return reply(
       uiHost()
-        ? `${runs.length} runs for ${project} — rendered in the dashboard widget.`
-        : listText(project, runs.slice(0, 20)),
-      { project, dir, runs }
+        ? `${runs.length} of ${history.length} runs for ${project} — ` +
+          "rendered in the dashboard widget."
+        : listText(project, runs, history.length),
+      { project, dir, runs, total: history.length, limit: max }
     );
   });
 
@@ -174,13 +242,14 @@ export async function mcp() {
       "captured command output. index counts from 1, newest first.",
     inputSchema: {
       index: z.number().int().min(1).describe("1-based index, newest first"),
-      project: z.string().optional()
-        .describe("Project slug; defaults to the current repo's project")
+      project: projectArg,
+      dir: dirArg
     },
     _meta: { ui: { resourceUri: DASHBOARD_URI } }
-  }, async ({ index, project: explicit }) => {
-    const { project, dir } = resolveProject(explicit);
-    if (!project) return reply("No project resolved.", {});
+  }, async ({ index, project: explicit, dir: explicitDir }) => {
+    const { project, dir } =
+      resolveProject({ project: explicit, dir: explicitDir, roots: await clientRoots() });
+    if (!project) return reply("No project resolved — pass `project` or `dir`.", {});
     const history = readRuns(project);
     const run = history[index - 1];
     if (!run) return reply(`No run #${index} (${history.length} recorded).`, {});
@@ -197,7 +266,7 @@ export async function mcp() {
     description:
       "Execute a repo's Highball checks (fast rules or the full suite). " +
       "Blocks until done; the run lands in the journal and, when reporting " +
-      "is configured, on the dashboard.",
+      "is configured, in PostHog.",
     inputSchema: {
       dir: z.string().optional()
         .describe("Repo root containing .highball/checks.yml; defaults to cwd"),
@@ -205,9 +274,10 @@ export async function mcp() {
     },
     _meta: { ui: { resourceUri: DASHBOARD_URI } }
   }, async ({ dir, fast }) => {
-    // No dir given → the current project's repo (from its journal), so
-    // widget-initiated re-runs work from hosts with no useful cwd.
-    const cwd = dir || resolveProject(null).dir || process.cwd();
+    // The widget passes the dir it was grounded with, so re-runs work from
+    // hosts with no useful cwd; otherwise resolve the same way list_runs
+    // does and let the child's own error explain a missing checks.yml.
+    const cwd = dir || resolveProject({ roots: await clientRoots() }).dir || process.cwd();
     const child = spawnSync(
       process.execPath,
       [ BIN_PATH, "run", ...(fast ? [ "--fast" ] : []) ],

package/lib/posthog.js

@@ -0,0 +1,149 @@
+// The runner's telemetry sink. Enforcement is local and always works;
+// this is the witness half, and it is deliberately somebody else's
+// server. An earlier iteration shipped a bespoke Rails dashboard, which
+// meant hosting, auth, and data custody for what is ultimately a
+// warehouse query — so a team points at their own PostHog instead.
+//
+// The whole run leaves in ONE request. The old protocol opened a run,
+// POSTed each result, then PATCHed the status: twenty round trips for an
+// eighteen-rule run. PostHog events are immutable and append-only, which
+// suits a runner that already defers all reporting to after the checks
+// finish — nothing to open, nothing to finalize.
+//
+// Best-effort, always: failures warn and return. A dead analytics
+// endpoint must never block an agent.
+import { hostname, userInfo } from "node:os";
+import { git } from "./git.js";
+
+const TIMEOUT_MS = 15_000;
+
+// Two event types, and deliberately no third. `highball_run` answers
+// "how are runs doing" and `highball_check` answers "which rules are
+// earning their keep"; every question we set out to ask breaks down
+// from one of those.
+export const RUN_EVENT = "highball_run";
+export const CHECK_EVENT = "highball_check";
+
+// Returns true when the batch was accepted, false when reporting was
+// skipped or failed — the caller journals either way.
+export async function reportPosthog({
+  host, key, project, results, hook, fastOnly, startedAt, durationMs, branch,
+  commitSha, version
+}) {
+  try {
+    const batch = buildEvents({
+      project, results, hook, fastOnly, startedAt, durationMs, branch, commitSha,
+      version, distinctId: distinctId()
+    });
+
+    const response = await fetch(new URL("/batch/", host), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ api_key: key, batch }),
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+    if (response.status >= 300) {
+      throw new Error(`${response.status}: ${(await response.text()).slice(0, 200)}`);
+    }
+
+    console.log(`reported ${batch.length} events to ${new URL(host).host}`);
+    return true;
+  } catch (error) {
+    console.error(`highball posthog reporting skipped: ${error.message}`);
+    return false;
+  }
+}
+
+// Pure, so the event shape can be tested without a network or a clock.
+export function buildEvents({
+  project, results, hook, fastOnly, startedAt, durationMs, branch, commitSha,
+  version, distinctId
+}) {
+  const timestamp = startedAt.toISOString();
+  const trigger = fastOnly ? "edit" : "stop";
+  const sessionKey =
+    hook?.session_id || process.env.HIGHBALL_SESSION_KEY || `manual-${hostname()}`;
+
+  // Repeated on every event rather than joined at query time. PostHog has
+  // no joins back to a "run" table, so a breakdown like "failure rate by
+  // rule, on this branch only" needs branch to sit on the check event
+  // itself.
+  const shared = {
+    project,
+    branch,
+    commit: commitSha,
+    trigger,
+    session_key: sessionKey,
+    agent: hook?.session_id ? "claude-code" : "manual",
+    runner_version: version,
+    // PostHog surfaces these in its UI as the sending client.
+    $lib: "highball",
+    $lib_version: version
+  };
+
+  const failed = results.filter((result) => !result.passed);
+  const todo = results.filter((result) => result.todo);
+
+  const events = [ {
+    event: RUN_EVENT,
+    distinct_id: distinctId,
+    timestamp,
+    properties: {
+      ...shared,
+      status: failed.length === 0 ? "passed" : "failed",
+      duration_ms: durationMs,
+      rules_total: results.length,
+      rules_passed: results.length - failed.length - todo.length,
+      rules_failed: failed.length,
+      rules_todo: todo.length,
+      // The denominator for any "how often does rule X fail" question that
+      // spans runs whose rulesets differ.
+      rules_run: results.map((result) => result.rule.id),
+      failed_rules: failed.map((result) => result.rule.id)
+    }
+  } ];
+
+  for (const result of results) {
+    events.push({
+      event: CHECK_EVENT,
+      distinct_id: distinctId,
+      timestamp,
+      properties: {
+        ...shared,
+        rule_id: result.rule.id,
+        rule_name: result.rule.name,
+        status: result.todo ? "todo" : result.passed ? "passed" : "failed",
+        duration_ms: result.durationMs,
+        // A one-line summary, never the log tail. Multi-kilobyte blobs in
+        // event properties bloat the column store and slow every query that
+        // touches it; the full output is already on disk in the journal.
+        summary: summarize(result),
+        command:
+          result.rule.run ?? (result.rule.rubric ? `judge ${result.rule.rubric}` : null)
+      }
+    });
+  }
+
+  return events;
+}
+
+function summarize(result) {
+  if (result.todo) return "planned — not implemented yet";
+  if (result.passed) return null;
+  return result.output.split("\n").find((line) => line.trim())?.trim().slice(0, 120) ?? null;
+}
+
+// Who the run belongs to. The git identity is the one that means anything
+// across machines — the same person on a laptop and a devcontainer should
+// be one person — with the machine as the fallback when git has no
+// identity configured (CI images, fresh containers).
+export function distinctId(env = process.env) {
+  if (env.HIGHBALL_POSTHOG_DISTINCT_ID) return env.HIGHBALL_POSTHOG_DISTINCT_ID;
+  const email = git("git config user.email");
+  if (email) return email;
+  try {
+    return `${userInfo().username}@${hostname()}`;
+  } catch {
+    return `host-${hostname()}`;
+  }
+}

package/lib/run.js

@@ -1,15 +1,27 @@
 // `highball run [--fast]` — the enforcement half. Runs each rule, prints
 // progress, exits 2 with failures on stderr (the Claude Code hook
 // contract: a Stop hook reading exit 2 blocks the agent and feeds the
-// output back). Reporting is the witness half and is best-effort: a dead
-// dashboard must never block the agent.
+// output back). Reporting is the witness half and is best-effort: an
+// unreachable PostHog must never block the agent.
 import { execSync, spawnSync } from "node:child_process";
-import { loadConfig, resolveReporting, commandFor } from "./config.js";
+import { readFileSync } from "node:fs";
+import {
+  CONFIG_PATH, DISABLED_MARKER, disabledByEnv, disabledByMarker,
+  loadConfig, resolvePosthog, commandFor
+} from "./config.js";
 import { appendRun } from "./journal.js";
-import { git, report } from "./report.js";
+import { readStamp, treeFingerprint, writeStamp } from "./stamp.js";
+import { git } from "./git.js";
+import { reportPosthog } from "./posthog.js";
 import { judge } from "./judge.js";
 import { latestUserPrompt } from "./transcript.js";
 
+// Stamped onto reported events so a query can tell which runner
+// produced them — rule semantics change between releases.
+const VERSION = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+).version;
+
 export async function run(args) {
   // When an AI-judged rule spawns a judge session inside this repo, the
   // judge inherits the repo's hooks — and its Stop hook would re-enter
@@ -17,6 +29,25 @@ export async function run(args) {
   // loop.
   if (process.env.HIGHBALL_JUDGE) return 0;
 
+  // Off switch #1, deliberately ahead of the config load: HIGHBALL_DISABLED
+  // is the one to reach for mid-task, so it has to work even when
+  // checks.yml is itself the thing in the way. Per machine, nothing to
+  // commit, nothing to accidentally push at a teammate.
+  if (disabledByEnv()) {
+    console.log("highball: disabled by HIGHBALL_DISABLED — no checks run");
+    return 0;
+  }
+
+  // Off switch #2, also ahead of the config load and for the same reason:
+  // the marker is a bare file next to checks.yml, so it still works when
+  // checks.yml is itself what's in the way.
+  const marker = disabledByMarker();
+  if (marker) {
+    const why = marker.reason ? ` (${marker.reason})` : "";
+    console.log(`highball: disabled by ${DISABLED_MARKER}${why} — no checks run`);
+    return 0;
+  }
+
   const fastOnly = args.includes("--fast");
   let config;
   try {
@@ -26,6 +57,29 @@ export async function run(args) {
     return 1;
   }
 
+  // Off switch #2, the committed counterpart: this repo isn't using
+  // Highball right now, for everyone who clones it. Neither switch is ever
+  // silent — a guardrail that has stopped guarding should say so on every
+  // single run, or the next person reads green and believes it.
+  if (config.enabled === false) {
+    console.log(
+      `highball: disabled by \`enabled: false\` in ${CONFIG_PATH} — no checks run`
+    );
+    return 0;
+  }
+
+  // --if-changed: a fast hook that also matches Bash fires after every
+  // command, and most commands are reads. Skip outright when the working
+  // tree is exactly where the last run left it. The fingerprint is taken
+  // now and stamped after the checks, so a formatter that rewrites files
+  // mid-run makes the next call run again rather than trust a stale pass.
+  const fingerprint = treeFingerprint();
+  if (args.includes("--if-changed") && fingerprint &&
+      fingerprint === readStamp(config.project, process.cwd())) {
+    console.log("highball: no changes since the last run — skipped");
+    return 0;
+  }
+
   // Rubric rules never join a fast run, even if a config marks one `fast`:
   // LLM latency and cost would be paid on every edit. That belongs at turn
   // end, and the invariant is enforced here rather than left to each repo.
@@ -46,7 +100,7 @@ export async function run(args) {
     process.stdout.write(`→ ${rule.name} ... `);
 
     // Placeholder rules are tracked, not run: they report as "todo" so
-    // the dashboard shows the full intended ruleset, and they can never
+    // the widget and PostHog show the full intended ruleset, and they can never
     // fail a run — an aspiration shouldn't block anyone.
     if (rule.todo) {
       console.log("todo (not implemented yet)");
@@ -86,21 +140,25 @@ export async function run(args) {
     results.push({ rule, passed, todo: false, durationMs, output });
   }
 
+  // Stamped pass or fail: after a failure the agent's next reads must not
+  // re-run and re-block; its next edit moves the tree and runs again.
+  if (fingerprint) writeStamp(config.project, process.cwd(), fingerprint);
+
   const failures = results.filter((result) => !result.passed);
   const durationMs = Date.now() - startedAt.getTime();
   const branch = git("git branch --show-current");
   const commitSha = git("git rev-parse HEAD");
 
-  const { url, token } = resolveReporting(config);
-  let reportedRunId = null;
-  if (url && token) {
-    reportedRunId = await report({
-      url, token, rules, results, hook, fastOnly, startedAt, branch, commitSha
+  const { host, key } = resolvePosthog(config);
+  if (host && key) {
+    await reportPosthog({
+      host, key, project: config.project, results, hook, fastOnly, startedAt,
+      durationMs, branch, commitSha, version: VERSION
     });
   }
 
   // The local journal is unconditional — `highball runs` works with no
-  // dashboard configured at all. Journal failures never fail the checks,
+  // reporting configured at all. Journal failures never fail the checks,
   // same policy as reporting.
   try {
     appendRun(config.project, {
@@ -118,7 +176,6 @@ export async function run(args) {
       branch,
       commit: commitSha,
       status: failures.length === 0 ? "passed" : "failed",
-      reported_run_id: reportedRunId,
       results: results.map((result) => ({
         id: result.rule.id,
         name: result.rule.name,
@@ -133,7 +190,7 @@ export async function run(args) {
         command:
           result.rule.run ??
           (result.rule.rubric ? `judge ${result.rule.rubric}` : null),
-        // Unlike the dashboard (failure tails only), the journal keeps
+        // Unlike PostHog (one-line summaries only), the journal keeps
         // every rule's output GitHub-Actions-style — it's the user's own
         // disk, and `highball runs <n> --logs` is the payoff.
         output_tail: result.output ? result.output.slice(-10_000) : null
@@ -156,7 +213,7 @@ export async function run(args) {
 
 // Claude Code hooks pass a JSON payload on stdin (session_id and
 // friends); that id groups this run with the rest of the agent's session
-// on the dashboard. A TTY means a human at a terminal — don't block on
+// in the journal and in PostHog. A TTY means a human at a terminal — don't block on
 // read.
 //
 // The deadline matters: a non-TTY stdin that nobody writes to and nobody

package/lib/runs.js

@@ -1,4 +1,4 @@
-// `highball runs [n] [--logs]` — the no-dashboard view of run history,
+// `highball runs [n] [--logs]` — the terminal view of run history,
 // read from the local journal. Bare: a table of recent runs, newest
 // first. With a number: that run's detail — failure output by default,
 // every rule's captured output with --logs.