failproofai 1.0.4-beta.1 → 1.0.4-beta.2

package/lib/auth/api-server-client.ts

@@ -253,6 +253,34 @@ export interface AuditReportBody {
     last_seen?: string;
     examples: string[];
   }[];
+  /**
+   * Credentials this machine found in its own transcripts.
+   *
+   * Optional on the wire, so a CLI newer than the api-server sends a field the
+   * server ignores rather than failing the whole digest — the harmful counts
+   * are the older half of the contract and must keep arriving either way.
+   *
+   * Every field here is a mask, a label, a length or a location. There is no
+   * shape of this object that carries a secret, because the record it is built
+   * from never stores one: `recordLeaks` fingerprints at detection time and
+   * keeps only the masked rendering.
+   */
+  leaks?: {
+    id: string;
+    display: string;
+    label: string;
+    length: number;
+    attributed: boolean;
+    name: string | null;
+    confidence: string;
+    first_seen: string;
+    last_seen: string;
+    occurrences: number;
+    cli: string;
+    project: string;
+    mechanism: string;
+    direction: "input" | "result";
+  }[];
 }
 
 export interface AuditReportResult {

package/lib/claude-sessions.ts

@@ -4,8 +4,14 @@
  * Claude stores transcripts at:
  *   <CLAUDE_PROJECTS_PATH>/<encoded-cwd>/<sessionId>.jsonl
  *
- * Subagent transcripts (when a session spawned subagents) live alongside:
+ * Subagent transcripts (when a session spawned subagents) live alongside, in two
+ * shapes — a direct child, and one nested per workflow run:
  *   <CLAUDE_PROJECTS_PATH>/<encoded-cwd>/<sessionId>/subagents/<agentId>.jsonl
+ *   <CLAUDE_PROJECTS_PATH>/<encoded-cwd>/<sessionId>/subagents/workflows/<runId>/<agentId>.jsonl
+ *
+ * Everything below `subagents/` is walked to a bounded depth rather than one
+ * level, because the second shape arrived after this module was written and the
+ * miss was most of the corpus. See `collectSubagentTranscripts`.
  *
  * The parser for these files lives in `lib/log-entries.ts` (`parseLogContent`,
  * `parseSessionLog`). This module exposes discovery only — the audit pipeline
@@ -70,6 +76,99 @@ export function listClaudeProjects(): ClaudeProjectFolder[] {
 /** Lists every JSONL transcript under one Claude project folder, including
  *  subagent transcripts under `<sessionId>/subagents/`. Returns [] on missing
  *  or unreadable paths. */
+/**
+ * Depth of nesting allowed below `subagents/`.
+ *
+ * The two shapes that exist today need 0 and 2 (`<agent>.jsonl` and
+ * `workflows/<runId>/<agent>.jsonl`). The cap is here so an unexpected layout —
+ * or a symlink cycle a future Claude build introduces — costs a bounded walk
+ * rather than an audit that never returns, and it is deliberately loose enough
+ * that a third shape lands inside it without another release.
+ */
+const MAX_SUBAGENT_DEPTH = 5;
+
+/**
+ * Collect every `.jsonl` beneath a session's `subagents/` directory.
+ *
+ * This used to read only the DIRECT children of `subagents/`, which was correct
+ * for the layout Claude shipped when it was written and silently wrong the day
+ * workflow runs started nesting their agents one level further down. On a
+ * machine that uses them the miss is most of the corpus: 1,839 transcripts on
+ * disk, 1,741 under `subagents/`, and 1,679 of those inside
+ * `subagents/workflows/<runId>/` — so the audit was walking 160 files, 8.7% of
+ * the evidence, and reporting the result as though it had read everything.
+ *
+ * ## Session ids come from the relative path, not the basename
+ *
+ * Every workflow run writes a `journal.jsonl` beside its agents, so basenames
+ * are NOT unique below this directory — 1,741 files share 1,613 distinct names
+ * on the machine this was found on. A basename id would collide those 128 files
+ * onto ~one row each, and `sessionId` is what the cache, the per-session
+ * detector state and the example attribution are keyed by, so the collision
+ * would silently merge unrelated sessions rather than fail.
+ *
+ * Nor is the path below `subagents/` unique on its own. A workflow run id is
+ * reused when its session is resumed, so `wf_3d609e92-a38/journal.jsonl` exists
+ * under two different parent sessions in the same project — found by asserting
+ * uniqueness over the real corpus, not by reasoning about it.
+ *
+ * The id is therefore the PARENT SESSION id followed by the path relative to
+ * `subagents/`, minus the extension, joined with `__`:
+ * `<parentUuid>__workflows__wf_123__agent-abc`. That is a filesystem path
+ * within the project, so it is unique by construction rather than by argument,
+ * and it names the session the subagent belongs to. `__` is safe as the joiner
+ * because no id Claude generates contains one — verified against 1,741 real
+ * files, zero hits. Top-level session ids are untouched.
+ *
+ * Symlinks are not followed. Nothing in the layout uses them, and following one
+ * is how a directory walk turns into an infinite loop.
+ */
+function collectSubagentTranscripts(
+  dir: string,
+  relPrefix: string,
+  project: ClaudeProjectFolder,
+  out: ClaudeTranscriptFile[],
+  depth: number,
+): void {
+  if (depth > MAX_SUBAGENT_DEPTH) return;
+  let entries: import("node:fs").Dirent[];
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    if (entry.isDirectory()) {
+      collectSubagentTranscripts(
+        join(dir, entry.name),
+        relPrefix ? `${relPrefix}__${entry.name}` : entry.name,
+        project,
+        out,
+        depth + 1,
+      );
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+    const stem = entry.name.slice(0, -".jsonl".length);
+    const transcriptPath = join(dir, entry.name);
+    try {
+      const s = statSync(transcriptPath);
+      out.push({
+        projectName: project.name,
+        cwd: project.cwd,
+        sessionId: relPrefix ? `${relPrefix}__${stem}` : stem,
+        transcriptPath,
+        mtimeMs: s.mtimeMs,
+        sizeBytes: s.size,
+        isSubagent: true,
+      });
+    } catch {
+      // unreadable — skip
+    }
+  }
+}
+
 export function listClaudeTranscripts(project: ClaudeProjectFolder): ClaudeTranscriptFile[] {
   const out: ClaudeTranscriptFile[] = [];
   let entries: import("node:fs").Dirent[];
@@ -99,34 +198,9 @@ export function listClaudeTranscripts(project: ClaudeProjectFolder): ClaudeTrans
         // unreadable — skip
       }
     } else if (entry.isDirectory() && UUID_RE.test(entry.name)) {
-      // Subagent transcripts at <sessionId>/subagents/<agentId>.jsonl
       const subDir = join(project.path, entry.name, "subagents");
       if (!existsSync(subDir)) continue;
-      let subEntries: import("node:fs").Dirent[];
-      try {
-        subEntries = readdirSync(subDir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const sub of subEntries) {
-        if (!sub.isFile() || !sub.name.endsWith(".jsonl")) continue;
-        const agentId = sub.name.slice(0, -".jsonl".length);
-        const transcriptPath = join(subDir, sub.name);
-        try {
-          const s = statSync(transcriptPath);
-          out.push({
-            projectName: project.name,
-            cwd: project.cwd,
-            sessionId: agentId,
-            transcriptPath,
-            mtimeMs: s.mtimeMs,
-            sizeBytes: s.size,
-            isSubagent: true,
-          });
-        } catch {
-          // unreadable — skip
-        }
-      }
+      collectSubagentTranscripts(subDir, entry.name, project, out, 0);
     }
   }
 

package/lib/cli-registry.ts

@@ -27,7 +27,7 @@
 import type { IntegrationType } from "@/src/hooks/types";
 
 /** Canonical CLI ids the registry knows about. Mirrors `INTEGRATION_TYPES`. */
-export const KNOWN_CLI_IDS = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "hermes", "openclaw", "factory", "devin", "antigravity", "goose", "grok", "qwen", "ori", "cline"] as const satisfies readonly IntegrationType[];
+export const KNOWN_CLI_IDS = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "hermes", "openclaw", "factory", "devin", "antigravity", "goose"] as const satisfies readonly IntegrationType[];
 export type CliId = (typeof KNOWN_CLI_IDS)[number];
 
 /** Per-CLI metadata consumed by the dashboard. */
@@ -99,38 +99,6 @@ const CLI_ENTRIES: Record<CliId, CliEntry> = {
     label: "Goose",
     badgeClasses: "bg-lime-500/10 text-lime-400 border-lime-500/20",
   },
-  grok: {
-    id: "grok",
-    label: "grok CLI",
-    // Neutral zinc, matching the design system's `--color-default`. Deliberately
-    // NOT a status hue: green/amber/red carry health meaning in this dashboard
-    // and must never be spent on identity. Neutral also happens to suit xAI's
-    // monochrome brand, and it is maximally far from qwen's magenta — the two
-    // were previously indistinguishable.
-    badgeClasses: "bg-zinc-500/10 text-zinc-200 border-zinc-500/20",
-  },
-  qwen: {
-    id: "qwen",
-    label: "Qwen Code",
-    // Magenta — the opposite pole from grok's neutral, and outside the
-    // status set (success/amber/orange/error) so it reads as identity.
-    badgeClasses: "bg-fuchsia-500/10 text-fuchsia-400 border-fuchsia-500/20",
-  },
-  ori: {
-    id: "ori",
-    label: "Ori",
-    // Sky — the badge set must be UNIQUE per CLI (a test asserts it), and
-    // violet/teal were already taken. Still outside the status set
-    // (success/amber/orange/error) so it reads as identity, not state.
-    badgeClasses: "bg-sky-500/10 text-sky-400 border-sky-500/20",
-  },
-  cline: {
-    id: "cline",
-    label: "Cline",
-    // Stone — the remaining neutral that is not zinc (grok's) and not a status
-    // colour.
-    badgeClasses: "bg-stone-500/10 text-stone-300 border-stone-500/20",
-  },
 };
 
 export function getCliEntry(id: string): CliEntry | undefined {

package/lib/download-session.ts

@@ -125,21 +125,6 @@ export async function resolveDownloadSource(
     return path ? { kind: "file", path } : null;
   }
 
-  if (cli === "grok") {
-    // grok writes a real chat_history.jsonl per session directory — stream it
-    // verbatim (no synthesis, like Factory).
-    const { findGrokTranscript } = await import("./grok-sessions");
-    const path = findGrokTranscript(sessionId);
-    return path ? { kind: "file", path } : null;
-  }
-
-  if (cli === "qwen") {
-    // qwen writes a real JSONL transcript per session — stream it verbatim.
-    const { findQwenTranscript } = await import("./qwen-sessions");
-    const path = findQwenTranscript(sessionId);
-    return path ? { kind: "file", path } : null;
-  }
-
   if (cli === "devin") {
     // Devin keeps sessions in SQLite (~/.local/share/devin/cli/sessions.db).
     // Synthesize a JSONL export of the session's raw chat_message rows.
@@ -167,28 +152,6 @@ export async function resolveDownloadSource(
     return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
   }
 
-  if (cli === "ori") {
-    // Ori keeps the whole conversation in one SQLite column
-    // (ori_agent_loop_history.prompt). Synthesize a JSONL export from the
-    // parsed entries — there is no per-session file to stream.
-    const { getOriSessionLog } = await import("./ori-sessions");
-    const result = await getOriSessionLog(sessionId);
-    if (!result) return null;
-    const body = result.entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
-  }
-
-  if (cli === "cline") {
-    // Cline stores a real per-session messages file, but it is a single JSON
-    // document rather than JSONL, so stream the parsed entries as JSONL for
-    // consistency with every other synthesized export.
-    const { getClineSessionLog } = await import("./cline-sessions");
-    const result = await getClineSessionLog(sessionId);
-    if (!result) return null;
-    const body = result.entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    return { kind: "synthesized", body, contentType: "application/x-ndjson", extension: "jsonl" };
-  }
-
   // Exhaustive — but TypeScript can't always see CliId is exhausted across the
   // if-chain above, so guard with a runtime fallback.
   const _exhaustive: never = cli;

package/lib/projects.ts

@@ -16,7 +16,7 @@ import { formatDate } from "./format-date";
 export const UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
 export const PATH_TRAVERSAL_RE = /(^|[\\/])\.\.($|[\\/])/;
 
-export type ProjectCli = "claude" | "codex" | "copilot" | "cursor" | "opencode" | "pi" | "hermes" | "openclaw" | "factory" | "devin" | "antigravity" | "goose" | "grok" | "qwen" | "ori" | "cline";
+export type ProjectCli = "claude" | "codex" | "copilot" | "cursor" | "opencode" | "pi" | "hermes" | "openclaw" | "factory" | "devin" | "antigravity" | "goose";
 
 export interface ProjectFolder {
   name: string;
@@ -171,10 +171,6 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
     { getDevinProjects },
     { getAntigravityProjects },
     { getGooseProjects },
-    { getGrokProjects },
-    { getQwenProjects },
-    { getOriProjects },
-    { getClineProjects },
   ] = await Promise.all([
     import("./codex-projects"),
     import("./copilot-projects"),
@@ -187,12 +183,8 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
     import("./devin-projects"),
     import("./antigravity-projects"),
     import("./goose-projects"),
-    import("./grok-projects"),
-    import("./qwen-projects"),
-    import("./ori-projects"),
-    import("./cline-projects"),
   ]);
-  const [claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose, grok, qwen, ori, cline] = await Promise.all([
+  const [claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose] = await Promise.all([
     getClaudeProjectFolders(),
     getCodexProjects().catch((error) => {
       logError("Error reading Codex projects:", error);
@@ -238,24 +230,8 @@ export async function getProjectFolders(): Promise<ProjectFolder[]> {
       logError("Error reading Goose projects:", error);
       return [] as ProjectFolder[];
     }),
-    getGrokProjects().catch((error) => {
-      logError("Error reading grok projects:", error);
-      return [] as ProjectFolder[];
-    }),
-    getQwenProjects().catch((error) => {
-      logError("Error reading Qwen projects:", error);
-      return [] as ProjectFolder[];
-    }),
-    getOriProjects().catch((error) => {
-      logError("Error reading Ori projects:", error);
-      return [] as ProjectFolder[];
-    }),
-    getClineProjects().catch((error) => {
-      logError("Error reading Cline projects:", error);
-      return [] as ProjectFolder[];
-    }),
   ]);
-  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose, grok, qwen, ori, cline);
+  return mergeProjectFolders(claude, codex, copilot, cursor, opencode, pi, hermes, openclaw, factory, devin, antigravity, goose);
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "failproofai",
-  "version": "1.0.4-beta.1",
-  "description": "Observability and enforcement for AI agent harnesses. 39 built-in policies hooked into 16 of them — Claude Code, Codex, Cursor, Hermes, OpenClaw and more — blocking the tool call before it runs. Local dashboard included, no account needed.",
+  "version": "1.0.4-beta.2",
+  "description": "Observability and enforcement for AI agent harnesses. 39 built-in policies hooked into 12 of them — Claude Code, Codex, Cursor, Hermes, OpenClaw and more — blocking the tool call before it runs. Local dashboard included, no account needed.",
   "bin": {
     "failproofai": "./dist/cli.mjs",
     "failproofaid": "./bin/failproofaid-shim.mjs"
@@ -80,14 +80,14 @@
     "access": "public"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.120.0",
+    "@anthropic-ai/sdk": "^0.123.0",
     "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.1",
     "@tanstack/react-virtual": "^3.14.10",
     "@testing-library/jest-dom": "^7.0.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.5",
-    "@types/node": "26.4.0",
+    "@types/node": "26.4.1",
     "@types/react": "19.2.18",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.1.0",
@@ -102,7 +102,7 @@
     "tailwind-merge": "^3.4.0",
     "tailwindcss": "^4.3.1",
     "typescript": "6.0.3",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.0"
   },
   "dependencies": {
     "html-to-image": "^1.11.13",
@@ -117,18 +117,19 @@
     "vite": "8.0.16",
     "undici": "7.29.0",
     "brace-expansion": "5.0.9",
-    "sharp": "0.35.0"
+    "sharp": "0.35.0",
+    "browserslist": "4.28.8"
   },
   "optionalDependencies": {
-    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.1",
-    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.1",
-    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.1",
-    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.1"
+    "@failproofai/failproofaid-linux-x64": "1.0.4-beta.2",
+    "@failproofai/failproofaid-linux-arm64": "1.0.4-beta.2",
+    "@failproofai/failproofaid-darwin-x64": "1.0.4-beta.2",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.4-beta.2"
   },
   "failproofaidBinaries": {
-    "linux-x64": "bda0aa2ff38779c247161c8928a6b5ca7dd846ae3ce5c6a6efd8b9509f67fca7",
-    "linux-arm64": "557699a24bec7a970839b952ee139b679e2feb0a505f5652a0e770e295ae148a",
-    "darwin-x64": "f23ff6e57f45ac51c0f3c7f5b876041100c119d7a3b81105a0df00018a2e2cc1",
-    "darwin-arm64": "7bc433a08d26fc148c21bc5471679440bf50300e47f1a2af505465476ca3352e"
+    "linux-x64": "3039575242ff240c68a79c4ebd4e0e35e865da99c6d8a46d1a17b2d7962cb47b",
+    "linux-arm64": "02fe993dca0faccb528c48472ca1d637274c562992ba7da1bc8d439103dbcc13",
+    "darwin-x64": "2be5a422007a773253611f24f2ad9e2a301f075392ed7bc2dc0f6354d3186696",
+    "darwin-arm64": "5882a4acd7317289346934290ac8277ca79edadb009e284c9fc0b23b74d321d7"
   }
 }

package/pi-extension/index.ts

@@ -25,7 +25,7 @@
  * spawns extensions with an undefined cwd contract, so paths are resolved
  * relative to this file via `import.meta.url`, NOT process.cwd().
  */
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync, readdirSync, statSync } from "node:fs";
@@ -64,6 +64,44 @@ function debug(msg: string): void {
   }
 }
 
+/**
+ * Forward an event whose VERDICT NOBODY READS, without blocking Pi.
+ *
+ * `callPolicy` is `spawnSync`, and Pi awaits its handlers serially on the
+ * startup path — so a `session_start` forward froze the whole TUI for as long
+ * as the subprocess took (measured floor 1.0-1.6s just to boot the binary,
+ * ceiling the full 60s timeout) and then threw the answer away. Three call
+ * sites are like that by design: `session_start`, `tool_result` and
+ * `session_shutdown` forward for the activity feed and for session-id
+ * continuity, and Pi cannot act on their return in any case
+ * (`ToolResultEventResult` has no `block`; the other two have no Result type
+ * at all).
+ *
+ * So they get a detached `spawn` instead. The event still reaches failproofai,
+ * the policies still run and still log, and Pi keeps rendering. Deliberately
+ * NOT used for `tool_call`, `user_bash`, `input` or `agent_end`: those four
+ * consume the decision, and blocking is what enforcement means.
+ */
+function forwardPolicy(eventName: string, payload: unknown): void {
+  const { cmd, args } = resolveSpawn();
+  debug(`forwardPolicy (detached) event=${eventName} cmd=${cmd}`);
+  try {
+    const child = spawn(cmd, [...args, "--hook", eventName, "--cli", "pi"], {
+      stdio: ["pipe", "ignore", "ignore"],
+      detached: false,
+    });
+    // A child that outlives its parent's interest must not keep the event loop
+    // alive, or Pi cannot exit until the subprocess does.
+    child.unref();
+    // EPIPE if the child died before stdin was consumed — fail-open, silently.
+    child.on("error", (err) => debug(`forward error ${err.message}`));
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify(payload));
+  } catch (err) {
+    debug(`FORWARD EXCEPTION ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
 function callPolicy(eventName: string, payload: unknown): { block: boolean; reason: string } {
   const { cmd, args } = resolveSpawn();
   debug(`callPolicy event=${eventName} cmd=${cmd}`);
@@ -417,7 +455,7 @@ export default function failproofaiBridge(pi: PiExtensionApi) {
   // need session_id continuity see the metadata.
   pi.on("session_start", (event: unknown): unknown => {
     const e = event as PiSessionStartEvent;
-    callPolicy("session_start", {
+    forwardPolicy("session_start", {
       session_id: resolveSessionId(e.sessionId, resolveCwd(e.cwd)),
       cwd: resolveCwd(e.cwd),
       reason: e.reason,
@@ -435,7 +473,7 @@ export default function failproofaiBridge(pi: PiExtensionApi) {
   pi.on("tool_result", (event: unknown): unknown => {
     const e = event as PiToolResultEvent;
     const canonicalTool = canonicalizeToolName(e.toolName);
-    callPolicy("tool_result", {
+    forwardPolicy("tool_result", {
       tool_name: canonicalTool,
       tool_input: canonicalizeToolInput(canonicalTool, e.input) ?? {},
       tool_response: { content: e.content, isError: e.isError },
@@ -500,7 +538,7 @@ export default function failproofaiBridge(pi: PiExtensionApi) {
   pi.on("session_shutdown", (event: unknown): unknown => {
     const e = event as PiSessionShutdownEvent;
     const cwd = resolveCwd(e.cwd);
-    callPolicy("session_shutdown", {
+    forwardPolicy("session_shutdown", {
       session_id: resolveSessionId(e.sessionId, cwd),
       cwd,
       reason: e.reason,

package/scripts/changelog-open.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Open a stub CHANGELOG section for the version a release just moved to.
+
+    changelog-open.py <changelog> <version> <published> [<date>]
+
+The companion to `changelog-section.py`, which REFUSES a release whose version has
+no section. Both PyPI publish workflows call this from `bump`, in the same commit
+that moves `_version.py`, so the two files can never disagree about which version
+`main` is open on.
+
+WHY THIS EXISTS AS AUTOMATION RATHER THAN A RULE. `bump` used to move the version
+alone, which left `main` on a version with no section — the exact state
+`changelog-section.py` refuses at release time and that
+`__tests__/ci/python-version-pipeline.test.ts` asserts against. Bump commits carry
+a skip-ci marker, so nothing went red until the next unrelated PR ran CI and came
+back failing for a reason that had nothing to do with it. That happened at the
+first publish (repaired by hand in #755, which named the recurrence and left it),
+and again at the second. It is not a rule a maintainer can be asked to remember:
+the commit that creates the state is written by a workflow, not a person.
+
+IDEMPOTENT ON PURPOSE. A re-run of `bump` against a `main` that already carries
+the section must be a no-op, not a second heading — two `## <version>` headings
+would put only the first one's body in the GitHub Release, silently. The version
+is matched with the same trailing word boundary the extractor uses, so `0.0.1b1`
+is not answered by `0.0.1b10`.
+
+The stub is deliberately non-empty prose, not a bare heading: an empty section
+fails `changelog-section.py` just as a missing one does, so a stub that could not
+release would only move the failure.
+
+Stdlib only, same reason as its two siblings: it runs in a job that installs
+nothing precisely because it is handed a token.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from datetime import datetime, timezone
+
+# The heading grammar CLAUDE.md fixes for the root changelog and both per-package
+# files follow — an EM DASH, and a date. Matched with `\b` after the version so a
+# request to open `0.0.1b1` is not satisfied by an existing `0.0.1b10`.
+_HEADING = "## {version} — {date}"
+
+#: What lands under the new heading. Non-empty by construction (see the module
+#: docstring), and it says who wrote it so the next reader does not go looking for
+#: the human who did not.
+_STUB = """Open for the next release. `{published}` published on {date} and the `bump` job
+moved the version here automatically; nothing has landed against `{version}` yet.
+Add entries as changes merge — this section becomes the GitHub Release body when
+it ships.
+"""
+
+
+class ChangelogError(Exception):
+    """A message a maintainer can act on, printed without a traceback."""
+
+
+def has_section(text: str, version: str) -> bool:
+    return re.search(rf"^##[ \t]+{re.escape(version)}\b", text, re.MULTILINE) is not None
+
+
+def open_section(text: str, version: str, published: str, date: str) -> str:
+    """`text` with a stub section for `version` above the topmost existing one."""
+    if has_section(text, version):
+        return text
+
+    block = _HEADING.format(version=version, date=date) + "\n\n" + _STUB.format(
+        published=published, version=version, date=date
+    )
+
+    # Above the newest existing section, never at the end: the file is
+    # reverse-chronological, and its preamble (title, and the grammar note the
+    # extractor depends on) sits above the first heading and must stay there.
+    first = re.search(r"^##[ \t]", text, re.MULTILINE)
+    if first:
+        return text[: first.start()] + block + "\n" + text[first.start() :]
+
+    # No sections yet — the first release off a fresh file. Keep the preamble and
+    # append, with exactly one blank line between.
+    return text.rstrip("\n") + "\n\n" + block
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) < 4:
+        print(__doc__ or "", file=sys.stderr)
+        return 2
+    path, version, published = argv[1], argv[2], argv[3]
+    date = argv[4] if len(argv) >= 5 else datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", date):
+        raise ChangelogError(f"'{date}' is not a YYYY-MM-DD date")
+
+    try:
+        with open(path, encoding="utf-8") as handle:
+            text = handle.read()
+    except OSError as exc:
+        raise ChangelogError(f"cannot read {path}: {exc}") from exc
+
+    if has_section(text, version):
+        print(f"{path} already has a '## {version}' section — nothing to open.")
+        return 0
+
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.write(open_section(text, version, published, date))
+    print(f"opened '## {version} — {date}' in {path}")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main(sys.argv))
+    except ChangelogError as error:
+        print(f"error: {error}", file=sys.stderr)
+        raise SystemExit(1) from None

package/src/audit/cli-adapters/index.ts

@@ -23,10 +23,6 @@ import { listFactoryTranscriptMetadata, streamFactoryEvents } from "./factory";
 import { listAntigravityTranscriptMetadata, streamAntigravityEvents } from "./antigravity";
 import { listDevinTranscriptMetadata, streamDevinEvents } from "./devin";
 import { listGooseTranscriptMetadata, streamGooseEvents } from "./goose";
-import { listGrokTranscriptMetadata, streamGrokEvents } from "./grok";
-import { listQwenTranscriptMetadata, streamQwenEvents } from "./qwen";
-import { listOriTranscriptMetadata, streamOriEvents } from "./ori";
-import { listClineTranscriptMetadata, streamClineEvents } from "./cline";
 
 export type { ListOpts };
 
@@ -127,26 +123,6 @@ export const ADAPTERS: Record<IntegrationType, CliAdapter> = {
     listTranscripts: listGooseTranscriptMetadata,
     streamEvents: streamGooseEvents,
   },
-  grok: {
-    cli: "grok",
-    listTranscripts: listGrokTranscriptMetadata,
-    streamEvents: streamGrokEvents,
-  },
-  qwen: {
-    cli: "qwen",
-    listTranscripts: listQwenTranscriptMetadata,
-    streamEvents: streamQwenEvents,
-  },
-  ori: {
-    cli: "ori",
-    listTranscripts: listOriTranscriptMetadata,
-    streamEvents: streamOriEvents,
-  },
-  cline: {
-    cli: "cline",
-    listTranscripts: listClineTranscriptMetadata,
-    streamEvents: streamClineEvents,
-  },
 };
 
 export function getAdapter(cli: IntegrationType): CliAdapter {