@globalmpc/nomore 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Global MPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,175 @@
-# Temporary Holding Version
+# nomore
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/@globalmpc/nomore)](https://www.npmjs.com/package/@globalmpc/nomore)
+[![ci](https://github.com/globalmpc/nomore/actions/workflows/ci.yml/badge.svg)](https://github.com/globalmpc/nomore/actions/workflows/ci.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+**Stop telling Claude Code the same thing twice.**
+
+![nomore: repeated instructions become CLAUDE.md rules](assets/demo.gif)
+
+**nomore finds the instructions you keep repeating to Claude Code and, with your yes, turns them into `CLAUDE.md`
+rules, so they survive compaction and new sessions.** Free and open source, by [GlobalMPC](https://github.com/globalmpc).
+It also reads OpenAI Codex CLI sessions and writes `AGENTS.md` rules ([Codex](#codex)).
+
+## What you get
+
+- **Stop repeating yourself.** See the instructions you've repeated in at least two sessions (last 30 days by
+  default), with counts and when you last said them.
+- **Rules that survive compaction.** Turn the ones you pick into `CLAUDE.md` rules, loaded in every session.
+- **Catch ignored rules.** It flags rules already in your `CLAUDE.md` that you still keep repeating, a sign Claude
+  isn't following them.
+- **A head start.** 20 ready rules from over 8,000 Claude Code GitHub issues: what users complain about most.
+- **Private by default.** Runs on your machine, sends nothing anywhere, uses no LLM, and writes only what you approve
+  ([what it reads and writes](#what-it-reads-and-writes)).
+
+## Quick start
+
+```bash
+npx @globalmpc/nomore            # what you keep telling Claude (sessions active in the last 30 days)
+npx @globalmpc/nomore --apply    # pick suggestions one by one (yes / no / edit) and add them to CLAUDE.md
+```
+
+Add the 20-rule pack to your global `CLAUDE.md` (the file `--apply` writes to; use `$CLAUDE_CONFIG_DIR` instead of
+`~/.claude` if you set it) in one line:
+
+```bash
+(echo; curl -fsSL https://raw.githubusercontent.com/globalmpc/nomore/main/rules/CLAUDE.md) >> ~/.claude/CLAUDE.md
+```
+
+Using Codex? See [Codex](#codex) for the same commands and where to put the pack.
+
+![What you type in chat doesn't survive compaction. CLAUDE.md does.](assets/compaction.png)
+
+## The rule pack: 20 rules from over 8,000 issues
+
+![Top 10 Claude Code behaviours by reactions](assets/chart.png)
+
+What the 20 rules stop:
+
+| Theme | Examples |
+|---|---|
+| **Touch only what you were asked to** | unrequested code comments, edits in plan mode, changing a test just to make it pass |
+| **Talk plainly** | "load-bearing", "belt-and-suspenders", answering in a different language than yours |
+| **Never destroy work** | `reset --hard`, `push --force`, invented tool output |
+| **Keep your text as written** | curly quotes and em dashes turned into ASCII, transliterated non-ASCII letters |
+| **Work in the open** | looping instead of asking, long silent tool runs, claims about code it hasn't read |
+
+Top 5:
+
+- Don't add code comments unless they explain something non-obvious; match the comment density of the surrounding code, and stop when asked.
+  1 issue · 252 reactions · [#65961](https://github.com/anthropics/claude-code/issues/65961)
+- Don't use the word "load-bearing" or other recurring jargon; say what you mean in plain words.
+  1 issue · 186 reactions · [#53454](https://github.com/anthropics/claude-code/issues/53454)
+- Never run destructive git commands (`reset --hard`, `checkout -- .`, `clean -f`, `push --force`) or schedule them without explicit permission.
+  1 issue · 121 reactions · [#40710](https://github.com/anthropics/claude-code/issues/40710)
+- Keep typographic characters (curly quotes, em dashes, ellipses) exactly as written; don't replace them with ASCII.
+  1 issue · 61 reactions · [#1599](https://github.com/anthropics/claude-code/issues/1599)
+- Don't use the idiom "belt-and-suspenders"; vary phrasing and keep it literal.
+  1 issue · 44 reactions · [#61462](https://github.com/anthropics/claude-code/issues/61462)
+
+All 20, each linked to its issue: [`rules/CLAUDE.md`](rules/CLAUDE.md). To keep the pack in its own file (downloading
+again replaces it cleanly), save it next to your `CLAUDE.md` and import it with one line, `@nomore-rules.md`:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/globalmpc/nomore/main/rules/CLAUDE.md -o nomore-rules.md
+```
+
+Put both in your Claude config folder (`~/.claude/`, or `CLAUDE_CONFIG_DIR`) to use them in every project. Delete any
+rule you don't want. Run the one-line append above once: a second run adds the pack again under a second
+`## nomore rules` heading. Downloading `nomore-rules.md` again is safe, because it replaces the file.
+
+How they were chosen: every `anthropics/claude-code` issue labelled `area:model` or `data-loss`, fetched
+2026-10-31 (8,196 after dropping pull requests, duplicates and withdrawn reports). The 8,096 with words in their
+title were grouped by title similarity ≥ 0.5 and ranked by Σ(1 + reactions); 20 behaviours a `CLAUDE.md` rule can
+change were then picked by hand, from issues still open or closed as not planned. Each rule currently rests on one
+issue and its reactions. Reproduce with `bash scripts/fetch-issues.sh && pnpm mine`.
+
+**If a rule saved you a correction, star the repo so others find it.** Know a rule that belongs here?
+[Propose it](../../issues/new?template=propose-a-rule.md).
+
+## How the CLI works
+
+It reads your Claude Code transcripts, finds the instructions you repeat, groups similar wordings, and checks them
+against the rules you already have.
+
+```bash
+npx @globalmpc/nomore               # what you keep telling Claude (sessions active in the last 30 days)
+npx @globalmpc/nomore --apply       # pick suggestions one by one (yes / no / edit) and add them to CLAUDE.md
+npx @globalmpc/nomore --project .   # only this project; --apply then writes this project's CLAUDE.md
+npx @globalmpc/nomore --card        # a short summary to share: totals only
+```
+
+**Preview, honestly:** most things people repeat are tasks ("commit", "continue"), not lasting preferences, so not
+every suggestion is a rule. You choose what to keep; nothing is written without your yes; rules you already have
+(including `@`-imported files like the rule pack) are recognised.
+Filters are tuned for English, Korean and Indonesian. If it finds sessions but nothing repeats yet, it points you to
+the rule pack above.
+
+### Codex
+
+```bash
+npx @globalmpc/nomore --agent codex               # same report, from your Codex sessions
+npx @globalmpc/nomore --agent codex --apply       # add picked rules to the AGENTS.md Codex reads
+npx @globalmpc/nomore --agent codex --project .   # only this project; --apply then writes this project's AGENTS.md
+```
+
+Codex keeps its data in `CODEX_HOME` (default `~/.codex`). Add the rule pack to your global `AGENTS.md` (use
+`$CODEX_HOME` instead of `~/.codex` if you set it):
+
+```bash
+(echo; curl -fsSL https://raw.githubusercontent.com/globalmpc/nomore/main/rules/AGENTS.md) >> ~/.codex/AGENTS.md
+```
+
+`AGENTS.md` has no `@`-imports, so the "save it next to your file and import it" trick above is Claude-only; for Codex,
+append the text. If you have a non-blank `AGENTS.override.md` in the same folder, Codex reads that instead of `AGENTS.md`: append to it instead. Append it once; to update it, delete the old `## nomore rules` section first, keeping any rules you
+added with `--apply` (they go into that same section; a second append creates a second heading, and `--apply` writes
+into the first one). Delete any rule you don't want.
+
+How the Codex pack was chosen: every `openai/codex` issue labelled `model-behavior`, `tool-calls`, `context`, `agent`
+or `subagent`, fetched 2026-10-31 (6,503 after dropping pull requests, duplicates and withdrawn reports; 6,499 with
+words in their title), grouped by title similarity ≥ 0.5 and ranked by Σ(1 + reactions); 20 behaviours an `AGENTS.md`
+rule can change were then picked by hand. Each rule's issue is labelled `bug` or `model-behavior` (not `enhancement`),
+and is still open or closed as not planned. Each rule rests on one issue and its reactions. Unlike the Claude pack, it
+has no rule against destructive git commands: no eligible Codex issue reports it. Reproduce with
+`bash scripts/fetch-issues.sh --agent codex && pnpm mine --agent codex`.
+
+Not in the first Codex version:
+
+- It checks the `AGENTS.md` in `CODEX_HOME` (and in the `--project` folder with `--project`), not the ones in the
+  folders between your repo root and your working directory.
+- It doesn't model `project_doc_max_bytes` (by default Codex cuts project docs at 32 KiB) or
+  `project_doc_fallback_filenames`.
+- No revert or rejected-edit hints yet: for Codex, nomore reads what you typed and when you interrupted, not Codex's
+  edits or approvals.
+
+### What it reads and writes
+
+Runs locally on Node 20+ and makes no network requests (the package has no network code).
+
+- **Reads:** your Claude Code transcripts (`~/.claude/projects/*/*.jsonl`, or the same under `CLAUDE_CONFIG_DIR` if
+  you set it) and your `CLAUDE.md` files, including the files they `@`-import.
+- **Writes, only with `--apply` and only after your yes:** the `CLAUDE.md` you chose (via a temp file and rename, so
+  it is never half-written) and a log of adopted rules, `nomore/adopted.json` in that same config folder (readable
+  only by you).
+- **With `--agent codex`, reads:** `sessions/**/rollout-*.jsonl` under `CODEX_HOME` (default `~/.codex`) and the
+  `AGENTS.md` / `AGENTS.override.md` there (and in the `--project` folder with `--project`). Only sessions you typed in: subagent threads and `codex exec` runs are
+  skipped. **Writes, only with `--apply` and after your yes:** the file Codex reads in that folder
+  (`AGENTS.override.md` if it has content, else `AGENTS.md`; the `--project` folder with `--project`), through a temp
+  file and rename, and `nomore/adopted.json` under `CODEX_HOME` (readable only by you).
+- `--card` prints totals only, never message text.
+
+## Contributing
+
+Rules, wrong suggestions and code are all welcome: see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Development
+
+```bash
+pnpm install
+pnpm test
+```
+
+## License
+
+MIT

package/dist/apply.js

@@ -0,0 +1,74 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, realpath, rename, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+const HEADING = "## nomore rules";
+// Writes through a symlinked CLAUDE.md to its target. The temp file has a random name and is created exclusively,
+// so nothing planted next to the target can redirect the write. An existing file keeps its exact permissions; a new
+// one gets `newMode` narrowed by the umask; `forceMode` always applies (the adoption log is owner-only).
+const writeAtomic = async (path, text, opts = {}) => {
+    const target = await realpath(path).catch(() => path);
+    await mkdir(dirname(target), { recursive: true });
+    const existing = await stat(target).then((st) => st.mode & 0o777, () => undefined);
+    const mode = opts.forceMode ?? existing ?? opts.newMode ?? 0o666;
+    const tmp = join(dirname(target), `.${basename(target)}.nomore-${randomUUID()}.tmp`);
+    await writeFile(tmp, text, { mode, flag: "wx" });
+    if (opts.forceMode !== undefined || existing !== undefined)
+        await chmod(tmp, mode); // the umask may have narrowed it
+    await rename(tmp, target);
+};
+const readOrEmpty = (path) => readFile(path, "utf8").catch((e) => {
+    if (e.code === "ENOENT")
+        return "";
+    throw e;
+});
+// Spec › Machine-supported decision: chosen rules go at the end of the "## nomore rules" section; a rule already
+// written as a bullet anywhere in the file is skipped; existing content and line endings are kept; atomic write.
+export async function applyRules(target, rules) {
+    const old = await readOrEmpty(target);
+    const eol = old.includes("\r\n") ? "\r\n" : "\n";
+    const lines = old === "" ? [] : old.replace(/\r?\n$/, "").split(/\r?\n/);
+    const present = new Set(lines.map((l) => l.trim()).filter((l) => l.startsWith("- ")).map((l) => l.slice(2).trim()));
+    const added = [];
+    const skipped = [];
+    for (const rule of rules.map((r) => r.trim()).filter(Boolean)) {
+        if (present.has(rule))
+            skipped.push(rule);
+        else
+            present.add(rule), added.push(rule);
+    }
+    if (added.length === 0)
+        return { added, skipped };
+    const bullets = added.map((r) => `- ${r}`);
+    const h = lines.findIndex((l) => l.trim() === HEADING);
+    if (h < 0) {
+        while (lines.length > 0 && lines.at(-1).trim() === "")
+            lines.pop();
+        lines.push(...(lines.length > 0 ? [""] : []), HEADING, "", ...bullets);
+    }
+    else {
+        const next = lines.findIndex((l, i) => i > h && /^#{1,6}\s/.test(l));
+        let at = next < 0 ? lines.length : next;
+        while (at > h + 1 && lines[at - 1].trim() === "")
+            at--;
+        lines.splice(at, 0, ...(at === h + 1 ? ["", ...bullets] : bullets));
+    }
+    await writeAtomic(target, lines.join(eol) + eol);
+    return { added, skipped };
+}
+export async function recordAdoption(configDir, entry, nowIso) {
+    const file = join(configDir, "nomore", "adopted.json");
+    const raw = await readOrEmpty(file);
+    let log = [];
+    if (raw !== "") {
+        try {
+            log = JSON.parse(raw);
+            if (!Array.isArray(log))
+                throw new Error("not a JSON array");
+        }
+        catch (e) {
+            throw new Error(`${file} can't be read (${e.message}); fix or remove it`);
+        }
+    }
+    log.push({ ...entry, adoptedAt: nowIso });
+    await writeAtomic(file, JSON.stringify(log, null, 2) + "\n", { forceMode: 0o600 });
+}

package/dist/cli.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { parseArgs } from "node:util";
+import { applyRules, recordAdoption } from "./apply.js";
+import { codexRuleFile, resolveCodexHome } from "./codex.js";
+import { runPipeline } from "./pipeline.js";
+import { NOTHING_YET, NOTHING_YET_CODEX, RULE_PACK, RULE_PACK_CODEX, renderCard, renderReport, skippedFilesNote } from "./report.js";
+import { resolveConfigDir } from "./sessions.js";
+const USAGE = `Usage: nomore [--days <n>] [--agent claude|codex] [--project <path>] [--json | --card | --apply]
+
+Finds what you keep telling Claude Code (or Codex) and suggests CLAUDE.md (or AGENTS.md) rules. Runs locally; writes only with --apply.
+  --days <n>        sessions active in the last n days (default 30)
+  --agent <name>    claude (default) or codex; codex reads $CODEX_HOME/sessions (default ~/.codex)
+  --project <path>  only sessions from this project; also checks and writes its CLAUDE.md (AGENTS.md with --agent codex)
+  --json            machine-readable report
+  --card            short summary to share: totals only, no suggestion text
+  --apply           pick rules one by one and add them to CLAUDE.md (AGENTS.md with --agent codex)`;
+// One readable reason for a file error, instead of a stack trace with temp-file paths.
+const reason = (e) => {
+    const code = e.code;
+    return code === "EACCES" || code === "EPERM" ? "permission denied" : code === "EROFS" ? "read-only file system" : code === "EISDIR" ? "it is a folder" : e.message;
+};
+// With --project, name the project (a typo shouldn't read as "you have no sessions at all"), and say if it doesn't exist.
+const noSessions = (name, sessionsDir, days, pack, project) => project
+    ? `No ${name} sessions for ${project} in the last ${days} days.\n${existsSync(project) ? "" : "That folder doesn't exist; check the path.\n"}${pack}`
+    : `No ${name} sessions found in ${sessionsDir} in the last ${days} days\n${pack}`;
+// Spec › Machine-supported decision: nothing is written unless the user picks a rule.
+async function applyInteractively(report, target, configDir, nothingYet) {
+    if (report.skippedFiles)
+        console.log(skippedFilesNote(report));
+    if (report.suggestions.length === 0)
+        return console.log(nothingYet), 0;
+    const rl = createInterface({ input: process.stdin });
+    const lines = rl[Symbol.asyncIterator]();
+    // undefined means input ended: every caller treats it as quit, so it is never taken as an answer or rule text.
+    let answered = false;
+    const ask = async (q) => {
+        process.stdout.write(q);
+        const r = await lines.next();
+        const a = r.done ? undefined : String(r.value).trim();
+        // A terminal echoes the answer itself; piped input doesn't, so echo it and end the line (also on EOF).
+        if (!process.stdin.isTTY)
+            process.stdout.write(`${a ?? ""}\n`);
+        if (a !== undefined)
+            answered = true;
+        return a;
+    };
+    console.log(`Rules will be added to ${target}\n`);
+    const chosen = [];
+    for (const s of report.suggestions) {
+        const seen = `${s.count}× in ${s.sessions} sessions`;
+        const answer = (s.status === "ignored"
+            ? await ask(`Your rule "${s.matchedRule}" isn't followed (${seen}). Add a reworded rule? [e/n/q] `)
+            : await ask(`Add "${s.text}"? (${seen}) [y/n/e/q] `))?.toLowerCase();
+        if (answer === undefined || answer.startsWith("q"))
+            break;
+        if (answer.startsWith("y") && s.status === "new")
+            chosen.push({ groupId: s.id, text: s.text });
+        if (answer.startsWith("e")) {
+            const text = await ask("Rule: ");
+            if (text === undefined)
+                break;
+            if (text)
+                chosen.push({ groupId: s.id, text });
+        }
+    }
+    rl.close();
+    if (!answered && !process.stdin.isTTY)
+        console.log("--apply asks you one rule at a time; run it in a terminal, or use --json to read the suggestions.");
+    if (chosen.length === 0)
+        return console.log("No rules added."), 0;
+    let result;
+    try {
+        result = await applyRules(target, chosen.map((c) => c.text));
+    }
+    catch (e) {
+        // The write goes through a temp file and a rename, so nothing is half-written.
+        return console.error(`Couldn't write ${target}: ${reason(e)}. No rules were added.`), 1;
+    }
+    const { added, skipped } = result;
+    try {
+        for (const c of chosen.filter((c) => added.includes(c.text.trim())))
+            await recordAdoption(configDir, { ...c, text: c.text.trim(), target }, new Date().toISOString());
+    }
+    catch (e) {
+        console.error(`Rules were added, but the adoption log wasn't updated: ${e.message}`);
+    }
+    console.log(`✓ ${added.length} ${added.length === 1 ? "rule" : "rules"} added to ${target}` + (skipped.length ? ` (${skipped.length} already there)` : ""));
+    return 0;
+}
+async function main() {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            options: {
+                days: { type: "string", default: "30" },
+                agent: { type: "string", default: "claude" },
+                project: { type: "string" },
+                json: { type: "boolean" },
+                card: { type: "boolean" },
+                apply: { type: "boolean" },
+                help: { type: "boolean" },
+            },
+        }));
+    }
+    catch (e) {
+        console.error(`${e.message}\n\n${USAGE}`);
+        return 1;
+    }
+    if (values.help)
+        return console.log(USAGE), 0;
+    const days = Number(values.days);
+    if (!(days > 0))
+        return console.error(`--days must be a positive number\n\n${USAGE}`), 1;
+    if (values.agent !== "claude" && values.agent !== "codex")
+        return console.error(`--agent must be claude or codex\n\n${USAGE}`), 1;
+    const agent = values.agent;
+    if (values.apply && (values.json || values.card))
+        return console.error(`--apply can't be combined with --json or --card\n\n${USAGE}`), 1;
+    const codex = agent === "codex";
+    const configDir = codex ? resolveCodexHome(process.env, homedir()) : resolveConfigDir(process.env, homedir());
+    const sessionsDir = join(configDir, codex ? "sessions" : "projects");
+    const name = codex ? "Codex" : "Claude Code";
+    const pack = codex ? RULE_PACK_CODEX : RULE_PACK;
+    const empty = { scannedSessions: 0, skippedLines: 0, skippedFiles: 0, corrections: 0, suggestions: [] };
+    if (!existsSync(sessionsDir)) {
+        if (values.json)
+            return console.log(JSON.stringify(empty, null, 2)), 0;
+        const elsewhere = codex ? "If Codex keeps its data elsewhere, set CODEX_HOME to that folder." : "If Claude Code keeps its data elsewhere, set CLAUDE_CONFIG_DIR to that folder.";
+        // ponytail: the hint only covers a missing projects folder, not an empty one; widen if Codex-only users still get lost.
+        const codexDir = join(resolveCodexHome(process.env, homedir()), "sessions");
+        const hint = !codex && existsSync(codexDir) ? `\nFound Codex sessions in ${codexDir}; run nomore --agent codex` : "";
+        return console.log(`No ${name} sessions found in ${sessionsDir}\n${elsewhere}\n${pack}${hint}`), 0;
+    }
+    const project = values.project && resolve(values.project);
+    const report = await runPipeline({ configDir, days, project, nowMs: Date.now(), agent });
+    if (report.scannedSessions === 0)
+        return console.log(values.json ? JSON.stringify(report, null, 2) : noSessions(name, sessionsDir, days, pack, project)), 0;
+    if (values.apply)
+        return applyInteractively(report, codex ? await codexRuleFile(project ?? configDir) : join(project ?? configDir, "CLAUDE.md"), configDir, codex ? NOTHING_YET_CODEX : NOTHING_YET);
+    process.stdout.write(values.json ? JSON.stringify(report, null, 2) + "\n" : values.card ? renderCard(report) : renderReport(report, codex ? NOTHING_YET_CODEX : NOTHING_YET));
+    return 0;
+}
+main().then((code) => (process.exitCode = code), (e) => {
+    console.error(`nomore: ${reason(e)}`); // last resort: a message, not a stack trace
+    process.exitCode = 1;
+});

package/dist/codex.js

@@ -0,0 +1,156 @@
+import { createReadStream } from "node:fs";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, sep } from "node:path";
+import { createInterface } from "node:readline";
+export const resolveCodexHome = (env, home) => env.CODEX_HOME ?? join(home, ".codex");
+// The file Codex reads in a directory: a non-blank AGENTS.override.md replaces AGENTS.md. Used for both the rule check and --apply.
+// ponytail: JS trim() also strips a BOM, Rust's may not, so a BOM-only override could differ from Codex; unverified, very unlikely.
+// ponytail: this directory only; the repo-root-to-cwd walk, project_doc_max_bytes and fallback filenames are not modelled (#21).
+export async function codexRuleFile(dir) {
+    const override = join(dir, "AGENTS.override.md");
+    return (await readFile(override, "utf8").catch(() => "")).trim() ? override : join(dir, "AGENTS.md");
+}
+const isRec = (r) => !!r && typeof r === "object" && typeof r.type === "string" && !!r.payload && typeof r.payload === "object";
+// Lines of a file; the stream is closed when the caller stops early (300k-char prompts are not read for nothing).
+async function* lines(file) {
+    const input = createReadStream(file);
+    try {
+        yield* createInterface({ input, crlfDelay: Infinity });
+    }
+    finally {
+        input.destroy();
+    }
+}
+// Subagent threads (guardian review included) and codex exec runs are not typed by the user.
+const isScripted = (p) => p.originator === "codex_exec" || p.source === "exec" || (!!p.source && typeof p.source === "object" && "subagent" in p.source);
+// Accepts both the platform separator and "/", like the pipeline's own project filter.
+const inside = (cwd, project) => {
+    const root = project.replace(/[\\/]$/, "");
+    return cwd === project || cwd.startsWith(root + sep) || cwd.startsWith(root + "/");
+};
+// True if any cwd the session reports (session_meta, or a later turn_context after a directory change) is inside the project. Throws on an unreadable file.
+async function touchesProject(file, project) {
+    for await (const line of lines(file)) {
+        if (!line.includes('"cwd"'))
+            continue;
+        try {
+            const r = JSON.parse(line);
+            if (isRec(r) && (r.type === "session_meta" || r.type === "turn_context") && typeof r.payload.cwd === "string" && inside(r.payload.cwd, project))
+                return true;
+        }
+        catch { }
+    }
+    return false;
+}
+async function walk(dir) {
+    const out = [];
+    for (const e of (await readdir(dir, { withFileTypes: true }).catch(() => [])).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (e.isDirectory())
+            out.push(...(await walk(join(dir, e.name))));
+        else if (e.name.startsWith("rollout-") && e.name.endsWith(".jsonl"))
+            out.push(join(dir, e.name));
+    }
+    return out;
+}
+export async function listRollouts(codexHome, opts) {
+    const files = [];
+    for (const path of await walk(join(codexHome, "sessions"))) {
+        // Deleted since readdir: skip it. Any other stat error (EACCES) keeps the file, so parseRollout counts it unreadable.
+        const mtime = await stat(path).then((st) => st.mtimeMs, (e) => (e.code === "ENOENT" ? -1 : Infinity));
+        if (mtime < opts.sinceMs)
+            continue;
+        // Codex has no folder per project: the cwds are in the file. Lookalikes and turns outside the project are removed later by the cwd check in runPipeline.
+        // ponytail: a file with no cwd record (pre-envelope, cut-off) never matches, so --project drops it and it is not counted in skippedLines; add a count if that proves confusing.
+        if (opts.project !== undefined) {
+            const hit = await touchesProject(path, opts.project).catch(() => null); // null: unreadable, keep it so it is counted
+            if (hit === false)
+                continue;
+        }
+        files.push(path);
+    }
+    return files;
+}
+const parts = (content, type) => Array.isArray(content) ? content.filter((c) => c?.type === type && typeof c.text === "string").map((c) => c.text) : [];
+// The VS Code extension wraps typed text as "<wrapper heading>...\n## My request:\n<typed>"; only the typed part is the user's.
+// ponytail: only the one wrapper seen on real history; another shape (e.g. an IDE-context heading, or a `[N] ...` line before the heading, seen only in subagent files that are skipped whole) leaks until added to WRAPPERS/MARKER.
+const WRAPPERS = ["# Files mentioned by the user:"];
+const REQUEST_MARKER = /^## My request:.*$/m;
+const unwrap = (t) => {
+    if (!WRAPPERS.some((w) => t.trimStart().startsWith(w)))
+        return t;
+    const m = REQUEST_MARKER.exec(t);
+    return m ? t.slice(m.index + m[0].length) : "";
+};
+// A file that can't be read (permissions, a folder named rollout-*.jsonl) is reported as unreadable instead of ending the run.
+export async function parseRollout(file) {
+    try {
+        return { ...(await readRollout(file)), unreadable: false };
+    }
+    catch {
+        return { events: [], skippedLines: 0, unreadable: true };
+    }
+}
+async function readRollout(file) {
+    const events = [];
+    let skippedLines = 0;
+    let sessionId; // set by the first session_meta, which decides whether the file counts
+    let cwd = "";
+    let n = 0;
+    for await (const line of lines(file)) {
+        n++;
+        if (line.trim() === "")
+            continue;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            skippedLines++; // a rollout still being written ends in a partial line
+            continue;
+        }
+        // ponytail: rollouts from before the {timestamp,type,payload} envelope are only counted, not read; add a second parser if someone needs them.
+        if (!isRec(r)) {
+            skippedLines++;
+            continue;
+        }
+        const p = r.payload;
+        if (r.type === "session_meta") {
+            if (sessionId !== undefined)
+                continue; // later ones belong to a parent thread
+            if (isScripted(p))
+                return { events: [], skippedLines };
+            sessionId = String(p.id ?? "");
+            if (typeof p.cwd === "string")
+                cwd = p.cwd;
+            continue;
+        }
+        if (r.type === "turn_context") {
+            if (typeof p.cwd === "string")
+                cwd = p.cwd;
+            continue;
+        }
+        // Ranking needs a time; without one the record can't be placed, so it is dropped.
+        if (typeof r.timestamp !== "string" || Number.isNaN(Date.parse(r.timestamp)))
+            continue;
+        const base = { uuid: `${sessionId ?? ""}:${n}`, sessionId: sessionId ?? "", cwd, ts: r.timestamp };
+        if (r.type === "event_msg") {
+            if (p.type === "turn_aborted" && p.reason === "interrupted")
+                events.push({ ...base, kind: "user_marker", text: "interrupted" });
+        }
+        else if (r.type === "response_item") {
+            if (p.type === "message" && p.role === "user") {
+                // Injected context arrives as user messages too: AGENTS.md text and tag blocks.
+                const text = parts(p.content, "input_text").map(unwrap).filter((t) => !t.startsWith("# AGENTS.md instructions") && !t.trimStart().startsWith("<")).join("\n").trim();
+                if (text !== "")
+                    events.push({ ...base, kind: "user_text", text });
+            }
+            else if (p.type === "message" && p.role === "assistant") {
+                events.push({ ...base, kind: "assistant_text", text: parts(p.content, "output_text").join("\n") });
+            }
+            else if ((p.type === "function_call" || p.type === "custom_tool_call") && typeof p.name === "string") {
+                events.push({ ...base, kind: "assistant_tool_use", tool: p.name, input: {} });
+            }
+        }
+    }
+    return { events, skippedLines };
+}