@globalmpc/nomore 0.1.0 → 0.2.0

package/README.md

@@ -1,37 +1,86 @@
 # nomore
 
-**Stop telling Claude Code the same thing twice.**
+[![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)
 
-We read nearly 10,000 Claude Code GitHub issues about how the model behaves, and turned the most-reacted complaints
-into 20 ready `CLAUDE.md` rules. Install them in 10 seconds. Then let `npx @globalmpc/nomore` find the things *you* keep
-repeating.
+**Stop telling Claude Code the same thing twice.**
 
 ![nomore: repeated instructions become CLAUDE.md rules](assets/demo.gif)
 
-## Rule pack: 20 rules in 10 seconds
+**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
-curl -fsSL https://raw.githubusercontent.com/globalmpc/nomore/main/rules/CLAUDE.md -o nomore-rules.md
+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
 ```
 
-Then add one line to your `CLAUDE.md`: `@nomore-rules.md` (or put both in `~/.claude/` for every project). Every rule
-links to the issues behind it. Delete any you don't want; downloading again replaces the file.
+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 · 185 reactions · [#53454](https://github.com/anthropics/claude-code/issues/53454)
+  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 · 43 reactions · [#61462](https://github.com/anthropics/claude-code/issues/61462)
+  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-24 (7,994 after dropping pull requests, duplicates and withdrawn reports). The 7,897 with words in their
+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`.
@@ -39,9 +88,10 @@ issue and its reactions. Reproduce with `bash scripts/fetch-issues.sh && pnpm mi
 **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).
 
-## CLI *(preview)*
+## How the CLI works
 
-Finds the instructions **you** keep repeating across your Claude Code sessions and suggests them as rules.
+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)
@@ -50,14 +100,64 @@ npx @globalmpc/nomore --project .   # only this project; --apply then writes thi
 npx @globalmpc/nomore --card        # a short summary to share: totals only
 ```
 
-**Preview, honestly:** most things people repeat are tasks ("commit", "continue"), not lasting preferences. On our
-team's sessions about a third of the suggestions were real rules, so 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 nothing repeats yet, it points you to the
-rule pack above.
+**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
+```
 
-Runs locally on Node 20+. It reads your Claude Code transcripts (respects `CLAUDE_CONFIG_DIR`), sends nothing
-anywhere, and writes only the `CLAUDE.md` you choose plus a small log of adopted rules.
+`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
 

package/dist/cli.js

@@ -5,27 +5,48 @@ 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, renderCard, renderReport } from "./report.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>] [--project <path>] [--json | --card | --apply]
+const USAGE = `Usage: nomore [--days <n>] [--agent claude|codex] [--project <path>] [--json | --card | --apply]
 
-Finds what you keep telling Claude Code and suggests CLAUDE.md rules. Runs locally; writes only with --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)
-  --project <path>  only sessions from this project; also checks and writes its CLAUDE.md
+  --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`;
+  --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) {
+async function applyInteractively(report, target, configDir, nothingYet) {
+    if (report.skippedFiles)
+        console.log(skippedFilesNote(report));
     if (report.suggestions.length === 0)
-        return console.log(NOTHING_YET), 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();
-        return r.done ? "q" : String(r.value).trim();
+        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 = [];
@@ -33,21 +54,33 @@ async function applyInteractively(report, target, configDir) {
         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.startsWith("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;
-    const { added, skipped } = await applyRules(target, chosen.map((c) => c.text));
+    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());
@@ -64,6 +97,7 @@ async function main() {
         ({ values } = parseArgs({
             options: {
                 days: { type: "string", default: "30" },
+                agent: { type: "string", default: "claude" },
                 project: { type: "string" },
                 json: { type: "boolean" },
                 card: { type: "boolean" },
@@ -81,19 +115,36 @@ async function main() {
     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 configDir = resolveConfigDir(process.env, homedir());
-    const empty = { scannedSessions: 0, skippedLines: 0, corrections: 0, suggestions: [] };
-    if (!existsSync(join(configDir, "projects")))
-        return console.log(values.json ? JSON.stringify(empty, null, 2) : `No Claude Code sessions found in ${join(configDir, "projects")}`), 0;
+    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() });
+    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) : `No Claude Code sessions found in ${join(configDir, "projects")} in the last ${days} days`), 0;
+        return console.log(values.json ? JSON.stringify(report, null, 2) : noSessions(name, sessionsDir, days, pack, project)), 0;
     if (values.apply)
-        return applyInteractively(report, join(project ?? configDir, "CLAUDE.md"), configDir);
-    process.stdout.write(values.json ? JSON.stringify(report, null, 2) + "\n" : values.card ? renderCard(report) : renderReport(report));
+        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));
+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 };
+}

package/dist/detect.js

@@ -86,7 +86,44 @@ const FILLER = /^((pls|plz|please|yea|yeah|yep|yes|ok|okay|okey|now|so|just|also
 const NEGATION = /\b(not|no|never|don'?t|doesn'?t|didn'?t|isn'?t|aren'?t|won'?t|can'?t|cannot|shouldn'?t|without|jangan|tidak|bukan|tanpa)\b|지\s?마|말고|않|못/i;
 // A contrast tail ("use pnpm, not npm") qualifies a positive instruction; it doesn't negate it.
 const CONTRAST = /^(not|instead of|rather than)\b/i;
-export const isNegated = (text) => NEGATION.test(text.replace(/,\s*(not|instead of|rather than)\b.*$/i, ""));
+// Without the comma too, but only after a choice verb ("use pnpm not npm", "prefer tabs not spaces"): a bare
+// "X not Y" is usually an evaluation ("force pushes not ok", "do it not now") and stays negated. One word after
+// "not", two or more before, no auxiliary ("use what is not needed"), participle tail or evaluative/adverb tail.
+// ponytail: choice verbs and one-word tails only, so "run vitest not jest" and "use pnpm not the npm cli" stay negated.
+// EVAL_TAIL is not exhaustive: a missed word merges opposites ("use it not now"); extend it when one shows up.
+const CHOICE = /^(use|prefer|pick|choose|write|reply|respond|answer|install|go with|stick (with|to))\b/i;
+const EVAL_TAIL = /^(ok|okay|good|fine|bad|great|now|yet|again|anymore|always|ever|never|much|more|less|later|here|there|yes|no|it|this|that|me|you|them|flaky|needed|allowed|acceptable|ideal|welcome|useful|nice|cool|wise|appropriate|necessary|mandatory|helpful|safe|correct|right|wrong|true|today|tomorrow|first|twice|often|everywhere|anywhere|too|so|really|properly)\W*$/i;
+const AUX = /^(do|does|did|is|are|was|were|am|be|been|can|could|should|would|will|must|may|might|shall|have|has|had|need|try|\w+['’](s|re|m|ve|ll|d))$/i;
+const choiceBody = (text) => text.trim().replace(FILLER, "").replace(/^(always|i said)\s+/i, "");
+const isContrastWord = (w) => !/(ed|ing)\W*$/i.test(w) && !EVAL_TAIL.test(w);
+const dropBareContrast = (text) => {
+    const body = choiceBody(text);
+    const w = body.split(/\s+/);
+    const i = w.length - 2; // where "not" would be
+    return CHOICE.test(body) && i >= 2 && /^not$/i.test(w[i]) && !AUX.test(w[i - 1]) && isContrastWord(w[i + 1]) ? w.slice(0, i).join(" ") : text;
+};
+// A ", never …" tail is a contrast too (issue #18) before a description ("…, never an instruction") or, after a
+// tool-choice verb, before one word that isn't a common verb ("use pnpm, never npm"). Any other ", never …" stays
+// an instruction ("commit often, never amend", "answer briefly, never ramble", "use the API, never guess").
+// ponytail: NEVER_VERB is not exhaustive; a missed verb merges ("use X, never <verb>"); extend it when one shows up.
+const TOOL_CHOICE = /^(use|prefer|pick|choose|install|go with|stick (with|to))\b/i;
+const NEVER_VERB = /^(guess|assume|ask|skip|stop|wait|ramble|apologi[sz]e|lie|invent|hardcode|mock|retry|rewrite|refactor|rename|delete|remove|overwrite|force|amend|rebase|squash|merge|push|commit|deploy|publish|release|edit|change|touch|modify|comment|explain|summari[sz]e|speculate|hallucinate|loop|repeat|truncate|ignore)\W*$/i;
+const isContrastTail = (head, tail) => {
+    if (CONTRAST.test(tail) || /^never\s+(a|an|the)\s/i.test(tail))
+        return true;
+    const word = tail.match(/^never\s+(\S+)$/i)?.[1];
+    return word !== undefined && TOOL_CHOICE.test(choiceBody(head)) && isContrastWord(word) && !NEVER_VERB.test(word);
+};
+// The text without its ", never …" contrast tails, and those tails ("use pnpm, never npm, never yarn").
+const splitNeverTails = (text) => {
+    const tails = [];
+    for (let m = text.match(/^(.*),\s*(never\b.*)$/i); m && isContrastTail(m[1], m[2]); m = text.match(/^(.*),\s*(never\b.*)$/i)) {
+        tails.unshift(m[2]);
+        text = m[1];
+    }
+    return { head: text, tails };
+};
+export const isNegated = (text) => NEGATION.test(dropBareContrast(splitNeverTails(text.replace(/,\s*(not|instead of|rather than)\b.*$/i, "")).head));
 // Korean (spec › Repeated instructions): Hangul has no \b word boundaries, so these match as substrings.
 const KO_QUESTION = /뭐|무엇|뭔|어떻게|어떤|어디|언제|왜|얼마|몇|누구|어때|어떨까|(나요|까요|까|니|냐|습니까)[?？.!~]*$/;
 const KO_REQUEST = /(해\s?줘|주세요|줘|해\s?봐|하자|보자|부탁(해|합니다|드려요)?)[.!~]*$/;
@@ -103,8 +140,13 @@ const keep = (clause, question) => {
     const words = t.filter((x) => !PLACEHOLDER.test(x) && x.length > 1);
     return !t.includes("<url>") && words.length >= 2 && (t.length - words.length) * 2 <= t.length && !words.every((x) => ACK.has(x));
 };
-// Grouping tokens: plain plurals are singularised so "words" and "word" match.
-export const clauseTokens = (text) => tokens(normalize(text)).map((t) => (t.length > 3 && t.endsWith("s") && !t.endsWith("ss") ? t.slice(0, -1) : t));
+// Grouping tokens: plain plurals are singularised so "words" and "word" match. A contrast "never" counts like the
+// stopword "not", so "use pnpm, never npm" groups with "use pnpm, not npm".
+export const clauseTokens = (text) => {
+    const { head, tails } = splitNeverTails(text);
+    const asNot = head + tails.map((t) => `, not${t.slice("never".length)}`).join("");
+    return tokens(normalize(asNot)).map((t) => (t.length > 3 && t.endsWith("s") && !t.endsWith("ss") ? t.slice(0, -1) : t));
+};
 export function extractInstructions(events) {
     const signals = new Map(detectCorrections(events).map((c) => [c.uuid, c.signals]));
     return events.flatMap((e) => {
@@ -115,7 +157,7 @@ export function extractInstructions(events) {
             .filter((line) => !isPasted(line.trim()))
             .join("\n")
             .split(/\n+|(?<=[.;!?？])\s+|,\s+|\s+(?:and|but)\s+/i)
-            .reduce((parts, p) => (CONTRAST.test(p.trim()) && parts.length ? [...parts.slice(0, -1), `${parts.at(-1)}, ${p.trim()}`] : [...parts, p]), [])
+            .reduce((parts, p) => (parts.length && isContrastTail(parts.at(-1), p.trim()) ? [...parts.slice(0, -1), `${parts.at(-1)}, ${p.trim()}`] : [...parts, p]), [])
             .map((raw, i) => ({ c: raw.trim().replace(/[.;!?？]+$/, "").trim(), q: /[?？]\s*$/.test(raw), i }))
             .filter(({ c, q }) => keep(c, q))
             .map(({ c, i }) => ({ uuid: `${e.uuid}:${i}`, sessionId: e.sessionId, cwd: e.cwd, ts: e.ts, text: c, norm: normalize(c), signals: signals.get(e.uuid) ?? [] }));

package/dist/pipeline.js

@@ -1,4 +1,5 @@
 import { join, sep } from "node:path";
+import { codexRuleFile, listRollouts, parseRollout } from "./codex.js";
 import { clauseTokens, extractInstructions, isNegated } from "./detect.js";
 import { groupItems } from "./group.js";
 import { rankGroups } from "./rank.js";
@@ -7,12 +8,20 @@ import { listSessionFiles, parseSession } from "./sessions.js";
 import { Report } from "./types.js";
 const GROUP_THRESHOLD = 0.6; // spec › Grouping (clauses)
 export async function runPipeline(opts) {
-    const files = await listSessionFiles(opts.configDir, { sinceMs: opts.nowMs - opts.days * 86_400_000, project: opts.project });
+    const codex = opts.agent === "codex";
+    const [list, parse] = codex ? [listRollouts, parseRollout] : [listSessionFiles, parseSession];
+    const files = await list(opts.configDir, { sinceMs: opts.nowMs - opts.days * 86_400_000, project: opts.project });
     const corrections = [];
     let skippedLines = 0;
+    let scanned = files.length; // codex: only rollouts that yielded events (subagent/exec ones are skipped); claude keeps every file
+    let skippedFiles = 0;
     for (const f of files) {
-        const s = await parseSession(f);
+        const s = await parse(f);
+        if (codex && s.events.length === 0 && !s.unreadable)
+            scanned--; // an unreadable file still counts, as for Claude (#26)
         skippedLines += s.skippedLines;
+        if (s.unreadable)
+            skippedFiles++;
         corrections.push(...extractInstructions(s.events));
     }
     // Two project paths can share one encoded folder (/tmp/a-b, /tmp/a_b): keep only instructions from inside the project.
@@ -37,10 +46,12 @@ export async function runPipeline(opts) {
             signals: [...new Set(members.flatMap((m) => m.signals))].sort(),
         };
     });
-    const rules = await readRuleLines([...(opts.project ? [join(opts.project, "CLAUDE.md")] : []), join(opts.configDir, "CLAUDE.md")]);
+    const ruleFile = async (dir) => (codex ? codexRuleFile(dir) : join(dir, "CLAUDE.md"));
+    const rules = await readRuleLines([...(opts.project ? [await ruleFile(opts.project)] : []), await ruleFile(opts.configDir)], { imports: !codex });
     return Report.parse({
-        scannedSessions: files.length,
+        scannedSessions: scanned,
         skippedLines,
+        skippedFiles,
         corrections: corrections.length,
         suggestions: toSuggestions(rankGroups(groups, opts.nowMs), rules),
     });

package/dist/report.js

@@ -1,14 +1,21 @@
 // The public repo; change to the org's repo at handover (README's install link too).
 export const REPO_URL = "https://github.com/globalmpc/nomore";
-export const NOTHING_YET = `No instructions repeated across sessions yet.\nMeanwhile, start with the 20-rule pack: ${REPO_URL}/blob/main/rules/CLAUDE.md`;
+const pack = (file) => `Meanwhile, start with the 20-rule pack: ${REPO_URL}/blob/main/rules/${file}`;
+const nothingYet = (p) => `No instructions repeated across sessions yet.\n${p}`;
+export const RULE_PACK = pack("CLAUDE.md");
+export const NOTHING_YET = nothingYet(RULE_PACK);
+export const RULE_PACK_CODEX = pack("AGENTS.md");
+export const NOTHING_YET_CODEX = nothingYet(RULE_PACK_CODEX);
+export const skippedFilesNote = (r) => `${r.skippedFiles} unreadable ${r.skippedFiles === 1 ? "file" : "files"} skipped`;
 const line = (s) => `● ${s.text}\n  ${s.count}× in ${s.sessions} sessions, last ${s.lastSeen.slice(0, 10)}\n` +
     s.examples.map((e) => `  “${e.length > 80 ? e.slice(0, 79) + "…" : e}”`).join("\n");
-export function renderReport(r) {
-    const head = `nomore · ${r.scannedSessions} sessions · ${r.corrections} instructions` + (r.skippedLines ? ` · ${r.skippedLines} unreadable lines skipped` : "");
+export function renderReport(r, nothing = NOTHING_YET) {
+    const head = `nomore · ${r.scannedSessions} sessions · ${r.corrections} instructions` + (r.skippedLines ? ` · ${r.skippedLines} unreadable lines skipped` : "") +
+        (r.skippedFiles ? ` · ${skippedFilesNote(r)}` : "");
     const fresh = r.suggestions.filter((s) => s.status === "new");
     const ignored = r.suggestions.filter((s) => s.status === "ignored");
     if (r.suggestions.length === 0)
-        return `${head}\n\n${NOTHING_YET}\n`;
+        return `${head}\n\n${nothing}\n`;
     return [
         head,
         ...(fresh.length ? ["", "Repeated instructions", "", ...fresh.map(line)] : []),

package/dist/rules.js

@@ -8,7 +8,8 @@ import { Suggestion } from "./types.js";
 const RULE_MATCH = 0.3; // spec › Rule check
 // Bullet or sentence lines of the rules files; headings, blanks and missing files are skipped. A line "@path"
 // imports another file in its place (Claude Code's CLAUDE.md imports: relative to the file, or ~/), once each.
-export async function readRuleLines(paths) {
+// AGENTS.md has no imports (Codex), so callers pass imports: false and an "@x" line stays plain text.
+export async function readRuleLines(paths, { imports = true } = {}) {
     const seen = new Set();
     const read = async (path) => {
         if (seen.has(path))
@@ -18,7 +19,7 @@ export async function readRuleLines(paths) {
         const out = [];
         for (const raw of text.split("\n")) {
             const line = raw.trim();
-            const imp = line.match(/^@(\S+)$/);
+            const imp = imports ? line.match(/^@(\S+)$/) : null;
             if (imp)
                 out.push(...(await read(imp[1].startsWith("~/") ? join(homedir(), imp[1].slice(2)) : resolve(dirname(path), imp[1]))));
             else if (line !== "" && !line.startsWith("#"))

package/dist/sessions.js

@@ -17,7 +17,9 @@ export async function listSessionFiles(configDir, opts) {
         const names = await readdir(join(root, d)).catch(() => []);
         for (const f of names.filter((n) => n.endsWith(".jsonl")).sort()) {
             const path = join(root, d, f);
-            if ((await stat(path)).mtimeMs >= opts.sinceMs)
+            // Deleted since readdir: skip it. Any other stat error (EACCES) keeps the file, so parseSession counts it unreadable.
+            const mtime = await stat(path).then((st) => st.mtimeMs, (e) => (e.code === "ENOENT" ? -1 : Infinity));
+            if (mtime >= opts.sinceMs)
                 files.push(path);
         }
     }
@@ -32,10 +34,13 @@ const resultText = (c) => typeof c === "string" ? c : Array.isArray(c) ? c.map((
 function toEvents(r) {
     if (r.isSidechain === true || typeof r.uuid !== "string")
         return [];
+    // Ranking needs a time; without one the record can't be placed, so it is dropped like any other unknown shape.
+    if (typeof r.timestamp !== "string" || Number.isNaN(Date.parse(r.timestamp)))
+        return [];
     // sdk-cli, sdk-ts, sdk-py: Claude Code run by a script, whose "user" messages are program-written templates.
     if (typeof r.entrypoint === "string" && r.entrypoint.startsWith("sdk"))
         return [];
-    const base = { uuid: r.uuid, sessionId: String(r.sessionId ?? ""), cwd: String(r.cwd ?? ""), ts: String(r.timestamp ?? "") };
+    const base = { uuid: r.uuid, sessionId: String(r.sessionId ?? ""), cwd: String(r.cwd ?? ""), ts: r.timestamp };
     const content = r.message?.content;
     if (r.type === "user") {
         const injected = r.isMeta === true || r.isCompactSummary === true; // compaction summaries are written by Claude Code
@@ -74,22 +79,28 @@ function toEvents(r) {
     }
     return [];
 }
+// A file that can't be read (permissions, a folder named *.jsonl) is reported as unreadable instead of ending the run.
 export async function parseSession(file) {
     const events = [];
     let skippedLines = 0;
-    for await (const line of createInterface({ input: createReadStream(file), crlfDelay: Infinity })) {
-        if (line.trim() === "")
-            continue;
-        let r;
-        try {
-            r = JSON.parse(line);
+    try {
+        for await (const line of createInterface({ input: createReadStream(file), crlfDelay: Infinity })) {
+            if (line.trim() === "")
+                continue;
+            let r;
+            try {
+                r = JSON.parse(line);
+            }
+            catch {
+                skippedLines++; // a session still being written ends in a partial line
+                continue;
+            }
+            if (r && typeof r === "object")
+                events.push(...toEvents(r));
         }
-        catch {
-            skippedLines++; // a session still being written ends in a partial line
-            continue;
-        }
-        if (r && typeof r === "object")
-            events.push(...toEvents(r));
     }
-    return { events, skippedLines };
+    catch {
+        return { events: [], skippedLines: 0, unreadable: true };
+    }
+    return { events, skippedLines, unreadable: false };
 }

package/dist/types.js

@@ -48,6 +48,7 @@ export const Suggestion = z.object({
 export const Report = z.object({
     scannedSessions: z.number(),
     skippedLines: z.number(),
+    skippedFiles: z.number(),
     corrections: z.number(),
     suggestions: z.array(Suggestion),
 });

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@globalmpc/nomore",
-  "version": "0.1.0",
-  "description": "Stop telling Claude Code the same thing twice: a CLAUDE.md rule pack from ~10k issues, and a local tool that finds what you keep repeating.",
+  "version": "0.2.0",
+  "description": "Stop telling Claude Code or Codex the same thing twice: a CLAUDE.md rule pack from ~10k issues, and a local tool that finds what you keep repeating.",
   "keywords": [
     "claude-code",
     "claude",
     "claude-md",
+    "codex",
+    "openai-codex",
+    "agents-md",
     "ai-agents",
     "developer-tools",
     "cli"