@globalmpc/nomore 0.0.0-stage → 0.1.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,75 @@
-# 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.
+**Stop telling Claude Code the same thing twice.**
+
+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.
+
+![nomore: repeated instructions become CLAUDE.md rules](assets/demo.gif)
+
+## Rule pack: 20 rules in 10 seconds
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/globalmpc/nomore/main/rules/CLAUDE.md -o nomore-rules.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.
+
+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)
+- 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)
+
+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
+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).
+
+## CLI *(preview)*
+
+Finds the instructions **you** keep repeating across your Claude Code sessions and suggests them as rules.
+
+```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. 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.
+
+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.
+
+## 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,99 @@
+#!/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 { runPipeline } from "./pipeline.js";
+import { NOTHING_YET, renderCard, renderReport } from "./report.js";
+import { resolveConfigDir } from "./sessions.js";
+const USAGE = `Usage: nomore [--days <n>] [--project <path>] [--json | --card | --apply]
+
+Finds what you keep telling Claude Code and suggests CLAUDE.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
+  --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`;
+// Spec › Machine-supported decision: nothing is written unless the user picks a rule.
+async function applyInteractively(report, target, configDir) {
+    if (report.suggestions.length === 0)
+        return console.log(NOTHING_YET), 0;
+    const rl = createInterface({ input: process.stdin });
+    const lines = rl[Symbol.asyncIterator]();
+    const ask = async (q) => {
+        process.stdout.write(q);
+        const r = await lines.next();
+        return r.done ? "q" : String(r.value).trim();
+    };
+    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.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)
+                chosen.push({ groupId: s.id, text });
+        }
+    }
+    rl.close();
+    if (chosen.length === 0)
+        return console.log("No rules added."), 0;
+    const { added, skipped } = await applyRules(target, chosen.map((c) => c.text));
+    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" },
+                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.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 project = values.project && resolve(values.project);
+    const report = await runPipeline({ configDir, days, project, nowMs: Date.now() });
+    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;
+    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 0;
+}
+main().then((code) => (process.exitCode = code));

package/dist/detect.js

@@ -0,0 +1,123 @@
+import { normalize, tokens } from "./normalize.js";
+// Spec › Correction signals.
+const LOOKAHEAD = 3;
+const MAX_PHRASE = 400;
+const STARTS = /^(no|nope|don'?t|do not|stop|wrong|not that|instead|undo|revert|i said|i told you)\b/i;
+const CONTAINS = /\b(instead of|i said|i told you|don'?t|do not|never)\b/i;
+const isCorrectionPhrase = (text) => {
+    const t = text.trim();
+    return t.length <= MAX_PHRASE && (STARTS.test(t) || CONTAINS.test(t.slice(0, 80)));
+};
+export function detectCorrections(events) {
+    const signals = new Map(); // index of a user_text event → its signals
+    const add = (i, s) => (signals.get(i) ?? signals.set(i, new Set()).get(i)).add(s);
+    const nextTyped = (i) => {
+        for (let j = i + 1; j <= i + LOOKAHEAD && j < events.length; j++)
+            if (events[j].kind === "user_text")
+                return j;
+        return -1;
+    };
+    const edits = [];
+    events.forEach((e, i) => {
+        if (e.kind === "tool_rejected" || e.kind === "user_marker") {
+            const j = nextTyped(i);
+            if (j >= 0)
+                add(j, e.kind === "tool_rejected" ? "rejected" : "interrupt");
+        }
+        if (e.kind === "user_text" && i > 0 && events[i - 1].kind.startsWith("assistant") && isCorrectionPhrase(e.text ?? ""))
+            add(i, "phrase");
+        if (e.kind === "assistant_tool_use" && e.tool === "Edit") {
+            const { file_path, old_string, new_string } = e.input ?? {};
+            if (edits.some((x) => x.file === file_path && x.old === new_string)) {
+                for (let j = i - 1; j >= 0; j--)
+                    if (events[j].kind === "user_text") {
+                        add(j, "revert");
+                        break;
+                    }
+            }
+            edits.push({ file: file_path, old: old_string });
+        }
+    });
+    return [...signals.keys()].sort((a, b) => a - b).map((i) => {
+        const e = events[i];
+        const text = e.text ?? "";
+        return { uuid: e.uuid, sessionId: e.sessionId, cwd: e.cwd, ts: e.ts, text, norm: normalize(text), signals: [...signals.get(i)].sort() };
+    });
+}
+// Spec › Repeated instructions: every typed message becomes clauses; clauses that can't be a lasting preference are
+// dropped. Each clause keeps its message's correction signals for display.
+const MAX_CLAUSE = 120;
+const ACK = new Set("yes ok okay okey proceed go ahead continue sure thanks thank lets let start now then good great fine done next step right cool nice pls plz yea yeah yep keep going oke sip siap ya yuk lanjut terus teruskan ayo gas mantap aja saja silakan".split(" ")); // + Indonesian
+const PLACEHOLDER = /^<(url|file|id|n)>$/;
+const clean = (text) => text
+    .replace(/<pasted_content[^>]*>[\s\S]*?<\/pasted_content[^>]*>/g, "\n")
+    .replace(/<([\w-]+)[^>]*>[\s\S]*?<\/\1>/g, "\n")
+    .replace(/<\/?[\w-]+[^>]*>/g, "\n");
+// Pasted content is judged line by line, before clause splitting, so a log line can't leave a harmless-looking
+// fragment ("…limit reached, retry later" → "retry later"). Spec › Repeated instructions.
+const PASTED = [
+    /^\+/, // diff line
+    /[{}[\];]|=>|\(['"]/, // code punctuation
+    /^[\w$.]+\s*=\s*\S/, // name = value
+    /^[\w$.]+:\s*['"`]/, // name: 'value'
+    /^import\s+([\w$]+\s*$|.*\bfrom\b)/i, // import json / import x from 'y'
+    /^from\s+\S+\s+import\b/i,
+    /^(const|let|var)\s+\w+\s*=/,
+    /^(def|class|function)\s+\w+\s*[(:{]/,
+    /\w\([^)]*\)/, // call: openDb(), load(cfg)
+    /^(error|warning|warn|fatal|exception|traceback)\b/i,
+    /^at\s+\S+\s+\(/, // stack frame
+    /\berror:|exception|traceback|limit (reached|exceeded)/i,
+    /:$/, // heading that introduces pasted content
+];
+const isIdentifier = (line) => /^[A-Za-z_$][\w$]*$/.test(line) && /_|[a-z][A-Z]/.test(line);
+// A typed shell command: a known command and only ASCII arguments, short or with a flag or path, so sentences that
+// start with a command name ("git push only after review", "npm 말고 pnpm 써") are kept.
+const SHELL = /^(git|pnpm|npm|npx|yarn|node|python3?|pip3?|docker|kubectl|curl|wget|cd|ls|rm|mkdir|bash|sh|cargo|brew|gh|tsx|bun|deno|uv|ssh|sudo)(\s+[-\w./@:=~'"&|>]+)*\s*$/i;
+const isShellCommand = (line) => SHELL.test(line) && (line.split(/\s+/).length <= 3 || /\s-{1,2}\w|[/\\]|\.\w/.test(line));
+const isPasted = (line) => isIdentifier(line) || isShellCommand(line) || PASTED.some((re) => re.test(line));
+// One-off requests and questions recur because the task recurs, not because they are lasting preferences.
+const QUESTION = /^(what|whats|what's|how|why|when|where|which|who|can you|could you|would you|do you|is it|are you|should we|apa|apakah|bagaimana|gimana|berapa|kenapa|mengapa|kapan|di mana|dimana|siapa)\b/i;
+const REQUEST = /^(review|check|update|provide|crawl|seed|recommend|let me|lets|let's|then|and|fix|commit|push|continue|implement|create|give|add|retry|redo|try|run|double|do (it|this|that|the)|lanjut|lanjutkan|coba|cek|periksa|perbaiki|benerin|buat|buatkan|bikin|jalankan|tambahkan|hapus|kirim)\b/i;
+// A task verb can still open a lasting preference ("run tests before saying done"); these words keep it.
+const PREFERENCE_CUE = /\b(always|never|every|each|before|after|first|only|myself|by default|from now on|one by one|step by step|instead|selalu|jangan|tanpa|hanya|cuma|sebelum|sesudah|setelah|mulai sekarang|sendiri)\b/i;
+const FILLER = /^((pls|plz|please|yea|yeah|yep|yes|ok|okay|okey|now|so|just|also|tolong|mohon|oke|sip|siap|ya|yuk|silakan|ayo)\b[\s,]*)+/i;
+// A negated instruction ("do not use npm") must never join its positive form ("use npm"); grouping runs per polarity.
+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, ""));
+// Korean (spec › Repeated instructions): Hangul has no \b word boundaries, so these match as substrings.
+const KO_QUESTION = /뭐|무엇|뭔|어떻게|어떤|어디|언제|왜|얼마|몇|누구|어때|어떨까|(나요|까요|까|니|냐|습니까)[?？.!~]*$/;
+const KO_REQUEST = /(해\s?줘|주세요|줘|해\s?봐|하자|보자|부탁(해|합니다|드려요)?)[.!~]*$/;
+const KO_PREFERENCE = /항상|절대|지\s?마|말고|없이|금지|대신|앞으로|매번|무조건|먼저|전에|후에|다음부터|직접|자세히|간단히|짧게|쉽게/;
+const keep = (clause, question) => {
+    if (clause.length > MAX_CLAUSE || /^([-*#`|>]|\d+\.)/.test(clause))
+        return false;
+    const body = clause.replace(FILLER, "");
+    if (question || QUESTION.test(body) || (REQUEST.test(body) && !PREFERENCE_CUE.test(body)))
+        return false;
+    if ((KO_QUESTION.test(body) || KO_REQUEST.test(body)) && !KO_PREFERENCE.test(body))
+        return false;
+    const t = tokens(normalize(clause));
+    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));
+export function extractInstructions(events) {
+    const signals = new Map(detectCorrections(events).map((c) => [c.uuid, c.signals]));
+    return events.flatMap((e) => {
+        if (e.kind !== "user_text")
+            return [];
+        return clean(e.text ?? "")
+            .split("\n")
+            .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]), [])
+            .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/group.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+export function idf(docs) {
+    const df = new Map();
+    for (const d of docs)
+        for (const t of new Set(d))
+            df.set(t, (df.get(t) ?? 0) + 1);
+    return new Map([...df].map(([t, n]) => [t, Math.log(1 + docs.length / n)]));
+}
+const sortedSet = (ts) => [...new Set(ts)].sort();
+// Merge over sorted token sets: the sums run in token order, so the result is the same bit for bit both ways.
+function simSorted(a, b, w) {
+    let inter = 0, union = 0, i = 0, j = 0;
+    while (i < a.length || j < b.length) {
+        if (a[i] === b[j]) {
+            const x = w.get(a[i]) ?? 0;
+            inter += x;
+            union += x;
+            i++, j++;
+        }
+        else if (j >= b.length || (i < a.length && a[i] < b[j]))
+            union += w.get(a[i++]) ?? 0;
+        else
+            union += w.get(b[j++]) ?? 0;
+    }
+    return union === 0 ? 0 : inter / union;
+}
+export function similarity(a, b, w) {
+    return simSorted(sortedSet(a), sortedSet(b), w);
+}
+const byId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+// Items with no tokens (e.g. a bare "no") can't be compared or turned into a rule, so they are left out.
+export function groupItems(items, tokensOf, threshold) {
+    const xs = items.map((x) => ({ x, t: sortedSet(tokensOf(x)) })).filter((e) => e.t.length > 0);
+    xs.sort((a, b) => byId(a.x, b.x));
+    const toks = xs.map((e) => e.t);
+    const w = idf(toks);
+    const parent = xs.map((_, i) => i);
+    const find = (i) => {
+        while (parent[i] !== i)
+            i = parent[i] = parent[parent[i]];
+        return i;
+    };
+    const push = (m, k, v) => (m.get(k) ?? m.set(k, []).get(k)).push(v);
+    // Identical token sets always join (similarity 1), so only one item per distinct set takes part in the join.
+    const byKey = new Map();
+    toks.forEach((ts, i) => push(byKey, ts.join(" "), i));
+    const uniq = [...byKey.values()].map((same) => {
+        same.forEach((i) => (parent[find(i)] = find(same[0])));
+        return same[0];
+    });
+    // Exact prefix filtering. With tokens in a global order (rarest first), any pair with weighted Jaccard ≥ t shares a
+    // token within each one's prefix: the leading tokens while the remaining weight could still hold t × its total
+    // weight. Common tokens end up in suffixes, so they no longer make every pair a candidate.
+    const order = (a, b) => w.get(b) - w.get(a) || (a < b ? -1 : a > b ? 1 : 0);
+    const index = new Map();
+    const prefixes = uniq.map((i) => {
+        const total = toks[i].reduce((s, t) => s + w.get(t), 0);
+        let rest = total;
+        const prefix = [];
+        for (const t of [...toks[i]].sort(order)) {
+            if (rest < threshold * total - 1e-9)
+                break;
+            prefix.push(t);
+            rest -= w.get(t);
+        }
+        return prefix;
+    });
+    prefixes.forEach((p, u) => p.forEach((t) => push(index, t, u)));
+    prefixes.forEach((p, u) => {
+        const cands = new Set();
+        for (const t of p)
+            for (const v of index.get(t))
+                if (v > u)
+                    cands.add(v);
+        for (const v of cands) {
+            const [i, j] = [uniq[u], uniq[v]];
+            if (find(i) !== find(j) && simSorted(toks[i], toks[j], w) >= threshold)
+                parent[find(i)] = find(j);
+        }
+    });
+    const comps = new Map();
+    xs.forEach((_, i) => push(comps, find(i), i));
+    return [...comps.values()]
+        .map((idx) => {
+        // Score = summed similarity to the other members (pairs without a shared token score 0). Members with the same
+        // token set share a score, so it is computed once per distinct set: (copies − 1) × 1 + Σ copies × similarity.
+        // Rounded so float noise in the sums can't beat the ts tie-break.
+        const keys = new Map();
+        idx.forEach((i) => push(keys, toks[i].join(" "), i));
+        const reps = [...keys.values()];
+        const local = new Map();
+        reps.forEach((r, k) => toks[r[0]].forEach((t) => push(local, t, k)));
+        const keyScore = reps.map((r, k) => {
+            const others = new Set(toks[r[0]].flatMap((t) => local.get(t)).filter((m) => m !== k));
+            return Math.round(([...others].reduce((s, m) => s + reps[m].length * simSorted(toks[r[0]], toks[reps[m][0]], w), 0) + r.length - 1) * 1e9);
+        });
+        const scoreOf = new Map(reps.flatMap((r, k) => r.map((i) => [i, keyScore[k]])));
+        const score = (i) => scoreOf.get(i);
+        const best = idx
+            .map((i) => ({ i, s: score(i) }))
+            .sort((a, b) => b.s - a.s || (xs[a.i].x.ts < xs[b.i].x.ts ? -1 : xs[a.i].x.ts > xs[b.i].x.ts ? 1 : a.i - b.i))[0].i;
+        return {
+            id: createHash("sha1").update(toks[best].join(" ")).digest("hex").slice(0, 8),
+            members: idx.map((i) => xs[i].x),
+            representative: xs[best].x,
+        };
+    })
+        .sort((a, b) => byId(a.representative, b.representative));
+}

package/dist/issues.js

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+export const Issue = z.object({
+    id: z.string(),
+    title: z.string(),
+    url: z.string(),
+    reactions: z.number(),
+    ts: z.string(),
+    labels: z.array(z.string()),
+    state: z.string(), // "open", or the close reason: "completed", "not_planned", …
+});
+// Only the fields we use; the body is never read.
+const RawIssue = z.object({
+    number: z.number(),
+    title: z.string().nullable(),
+    html_url: z.string(),
+    created_at: z.string(),
+    labels: z.array(z.object({ name: z.string() })),
+    reactions: z.object({ total_count: z.number() }).optional(),
+    pull_request: z.unknown().optional(),
+    state: z.string(),
+    state_reason: z.string().nullable().optional(),
+});
+const EXCLUDED = new Set(["duplicate", "invalid"]);
+// The whole title is a retraction: "Withdrawn by the author", "[withdrawn]", "[Bug] (withdrawn)",
+// "[withdrawn] filed in error". A title that merely starts with the word ("Withdrawn API key …") is kept.
+const WITHDRAWN = /^\s*(?:\[[^\]]{0,30}\]\s*)?[\s\p{P}]*withdrawn(?:[\s\p{P}]+(?:by (?:the )?author|filed in error)\b.*)?[\s\p{P}]*$/iu;
+export function loadIssues(files) {
+    // First copy of each issue, with the labels of every copy, so an exclusion label in any file counts.
+    const byNumber = new Map();
+    for (const file of files) {
+        let raw;
+        try {
+            raw = z.array(RawIssue).parse(JSON.parse(readFileSync(file, "utf8")));
+        }
+        catch (e) {
+            throw new Error(`can't load issues from ${file}: ${e.message}`);
+        }
+        for (const r of raw) {
+            const seen = byNumber.get(r.number) ?? byNumber.set(r.number, { r, labels: new Set() }).get(r.number);
+            r.labels.forEach((l) => seen.labels.add(l.name));
+        }
+    }
+    return [...byNumber.keys()]
+        .sort((a, b) => a - b)
+        .map((n) => byNumber.get(n))
+        .filter(({ r, labels }) => r.pull_request === undefined && ![...labels].some((l) => EXCLUDED.has(l)) && !WITHDRAWN.test(r.title ?? ""))
+        .map(({ r, labels }) => Issue.parse({
+        id: String(r.number),
+        title: r.title ?? "",
+        url: r.html_url,
+        reactions: r.reactions?.total_count ?? 0,
+        ts: r.created_at,
+        labels: [...labels],
+        state: r.state === "open" ? "open" : (r.state_reason ?? r.state),
+    }));
+}
+// Strips short leading tags ("[BUG]", "[Feature Request]"); a title written entirely in brackets is kept.
+export const cleanTitle = (title) => title.replace(/^(\s*\[[^\]]{0,30}\])+/, "").trim();

package/dist/mine.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { groupItems } from "./group.js";
+import { cleanTitle } from "./issues.js";
+import { normalize, tokens } from "./normalize.js";
+export const IssueGroup = z.object({
+    id: z.string(),
+    weight: z.number(),
+    issues: z.number(),
+    reactions: z.number(),
+    representative: z.object({ id: z.string(), title: z.string(), url: z.string() }),
+    top: z.array(z.object({ id: z.string(), title: z.string(), url: z.string(), reactions: z.number(), state: z.string() })).max(5),
+});
+// Spec › Part 0: titles join at ≥ 0.5; weight = Σ(1 + reactions); ranked by weight, ties by group id.
+export function mineGroups(issues, threshold = 0.5) {
+    return groupItems(issues, (i) => tokens(normalize(cleanTitle(i.title))), threshold)
+        .map((g) => IssueGroup.parse({
+        id: g.id,
+        weight: g.members.reduce((s, i) => s + 1 + i.reactions, 0),
+        issues: g.members.length,
+        reactions: g.members.reduce((s, i) => s + i.reactions, 0),
+        representative: { id: g.representative.id, title: cleanTitle(g.representative.title), url: g.representative.url },
+        top: [...g.members]
+            .sort((a, b) => b.reactions - a.reactions || Number(a.id) - Number(b.id))
+            .slice(0, 5)
+            .map((i) => ({ id: i.id, title: i.title, url: i.url, reactions: i.reactions, state: i.state })),
+    }))
+        .sort((a, b) => b.weight - a.weight || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+// Titles are untrusted: escape markdown and HTML punctuation so they render as plain link text.
+const text = (s) => s.replace(/\s+/g, " ").replace(/[\\`*_[\]()<>#!|~]/g, "\\$&");
+export function renderTopGroups(gs, n) {
+    const rows = gs.slice(0, n).map((g, i) => {
+        const links = g.top.slice(0, 3).map((t) => `[#${t.id}](${t.url})`).join(" ");
+        return `| ${i + 1} | ${g.weight} | ${g.issues} | ${g.reactions} | [${text(g.representative.title)}](${g.representative.url}) | ${links} |`;
+    });
+    return ["| # | Weight | Issues | Reactions | Representative title | Top issues |", "|---|---|---|---|---|---|", ...rows, ""].join("\n");
+}

package/dist/normalize.js

@@ -0,0 +1,18 @@
+const STOPWORDS = new Set(("a an the and or but if then so to of in on at by for from with about as into is are was were be been am " +
+    "it its this that these those i me my we us our you your he she they them their do does did don t s " +
+    "not no please here there just very can will would should could have has had").split(" "));
+export function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/https?:\/\/\S+/g, "<url>")
+        // name.ext needs a name of 2+ chars with a letter, so "e.g." and "24.x" stay text.
+        .replace(/\S*[/\\]\S*|\b(?=[\w-]*[a-z])[\w-]{2,}\.[a-z][a-z0-9]{0,4}\b/g, "<file>")
+        .replace(/\b[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\b|\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*\d)[0-9a-f]{7,}\b/g, "<id>")
+        .replace(/\d+/g, "<n>")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function tokens(norm) {
+    // Placeholders stay whole ("<file>"), so they never match the word "file".
+    return (norm.match(/<(?:url|file|id|n)>|[\p{L}\p{N}]+/gu) ?? []).filter((t) => !STOPWORDS.has(t));
+}

package/dist/pipeline.js

@@ -0,0 +1,47 @@
+import { join, sep } from "node:path";
+import { clauseTokens, extractInstructions, isNegated } from "./detect.js";
+import { groupItems } from "./group.js";
+import { rankGroups } from "./rank.js";
+import { readRuleLines, toSuggestions } from "./rules.js";
+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 corrections = [];
+    let skippedLines = 0;
+    for (const f of files) {
+        const s = await parseSession(f);
+        skippedLines += s.skippedLines;
+        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.
+    if (opts.project) {
+        const root = opts.project;
+        corrections.splice(0, corrections.length, ...corrections.filter((c) => c.cwd === root || c.cwd.startsWith(root + sep) || c.cwd.startsWith(root + "/")));
+    }
+    // Grouping runs per polarity, and negated clauses carry a "<not>" token, so ids never collide across the two.
+    const byPolarity = [corrections.filter((c) => !isNegated(c.text)), corrections.filter((c) => isNegated(c.text))];
+    const grouped = byPolarity.flatMap((cs, negated) => groupItems(cs.map((c) => ({ id: c.uuid, ts: c.ts, c })), (x) => [...clauseTokens(x.c.text), ...(negated ? ["<not>"] : [])], GROUP_THRESHOLD));
+    const groups = grouped.map((g) => {
+        const members = g.members.map((m) => m.c);
+        return {
+            id: g.id,
+            members,
+            representative: g.representative.c,
+            count: members.length,
+            sessions: new Set(members.map((m) => m.sessionId)).size,
+            projects: new Set(members.map((m) => m.cwd)).size,
+            days: new Set(members.map((m) => m.ts.slice(0, 10))).size,
+            lastSeen: members.map((m) => m.ts).sort().at(-1),
+            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")]);
+    return Report.parse({
+        scannedSessions: files.length,
+        skippedLines,
+        corrections: corrections.length,
+        suggestions: toSuggestions(rankGroups(groups, opts.nowMs), rules),
+    });
+}

package/dist/rank.js

@@ -0,0 +1,18 @@
+const DAY_MS = 86_400_000;
+const HALF_LIFE_DAYS = 14;
+// Tasks repeat more often than preferences; a preference word in any clause triples a group's score. Korean has no
+// \b word boundaries, so its words are matched as plain substrings.
+const PREFERENCE = /\b(never|don'?t|do not|without|instead|always|only|stop|avoid|prefer|myself|too|selalu|jangan|tanpa|hanya|terlalu)\b|지 ?마|말고|없이|항상|절대|금지|대신|너무/i;
+const BOOST = 3;
+// Spec › Ranking: score = count × sessions × 0.5^(days since last / 14) × boost; shown if sessions ≥ 2.
+export function rankGroups(gs, nowMs) {
+    return gs
+        .filter((g) => g.sessions >= 2)
+        .map((g) => ({
+        ...g,
+        signals: g.sessions >= 3 && !g.signals.includes("repeated") ? [...g.signals, "repeated"] : g.signals,
+        score: g.count * g.sessions * 0.5 ** ((nowMs - Date.parse(g.lastSeen)) / DAY_MS / HALF_LIFE_DAYS) *
+            (g.members.some((m) => PREFERENCE.test(m.text)) ? BOOST : 1),
+    }))
+        .sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}

package/dist/report.js

@@ -0,0 +1,22 @@
+// 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 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` : "");
+    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,
+        ...(fresh.length ? ["", "Repeated instructions", "", ...fresh.map(line)] : []),
+        ...(ignored.length ? ["", "Rules you have, but the agent ignores", "", ...ignored.map((s) => `${line(s)}\n  rule: ${s.matchedRule}`)] : []),
+        "",
+    ].join("\n");
+}
+// Safe to share: totals only. Suggestion text can hold private words, so it never appears here.
+export function renderCard(r) {
+    return `nomore: ${r.scannedSessions} sessions, ${r.corrections} instructions, ${r.suggestions.length} repeated.\n`;
+}

package/dist/rules.js

@@ -0,0 +1,68 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { isNegated } from "./detect.js";
+import { idf, similarity } from "./group.js";
+import { normalize, tokens } from "./normalize.js";
+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) {
+    const seen = new Set();
+    const read = async (path) => {
+        if (seen.has(path))
+            return [];
+        seen.add(path);
+        const text = await readFile(path, "utf8").catch(() => "");
+        const out = [];
+        for (const raw of text.split("\n")) {
+            const line = raw.trim();
+            const imp = line.match(/^@(\S+)$/);
+            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("#"))
+                out.push(line.replace(/^([-*]|\d+\.)\s+/, ""));
+        }
+        return out;
+    };
+    const lines = [];
+    for (const p of paths)
+        lines.push(...(await read(resolve(p))));
+    return lines;
+}
+const template = (text) => {
+    const t = text.trim().replace(/^(no|nope)[,.!]*\s+|^don'?t do that[,.!]*\s+/i, "");
+    return t.charAt(0).toUpperCase() + t.slice(1);
+};
+export function toSuggestions(groups, ruleLines) {
+    const ruleToks = ruleLines.map((l) => tokens(normalize(l)));
+    const repToks = groups.map((g) => tokens(g.representative.norm));
+    const w = idf([...ruleToks, ...repToks]);
+    return groups.map((g, gi) => {
+        let best = -1, bestSim = 0;
+        const negated = isNegated(g.representative.text);
+        ruleToks.forEach((rt, ri) => {
+            if (isNegated(ruleLines[ri]) !== negated)
+                return; // "Use npm" doesn't cover "don't use npm"
+            const s = similarity(repToks[gi], rt, w);
+            if (s > bestSim)
+                [best, bestSim] = [ri, s];
+        });
+        const ignored = best >= 0 && bestSim >= RULE_MATCH;
+        return Suggestion.parse({
+            id: g.id,
+            text: template(g.representative.text),
+            status: ignored ? "ignored" : "new",
+            ...(ignored ? { matchedRule: ruleLines[best] } : {}),
+            count: g.count,
+            sessions: g.sessions,
+            projects: g.projects,
+            days: g.days,
+            score: g.score,
+            lastSeen: g.lastSeen,
+            examples: [...new Set(g.members.map((m) => m.text.trim()))].slice(0, 3),
+            signals: g.signals,
+        });
+    });
+}

package/dist/sessions.js

@@ -0,0 +1,95 @@
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+export const resolveConfigDir = (env, home) => env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
+// Claude Code names a project's folder after its path with every non-alphanumeric character replaced by "-".
+const encodeProject = (path) => path.replace(/[^a-zA-Z0-9]/g, "-");
+export async function listSessionFiles(configDir, opts) {
+    const root = join(configDir, "projects");
+    const dirs = await readdir(root).catch(() => []);
+    const files = [];
+    for (const d of dirs.sort()) {
+        // Sessions started in a subfolder live in their own encoded folder ("-repo-web"); lookalikes ("-repo-other") are
+        // removed later by the cwd check in runPipeline.
+        if (opts.project !== undefined && d !== encodeProject(opts.project) && !d.startsWith(encodeProject(opts.project) + "-"))
+            continue;
+        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)
+                files.push(path);
+        }
+    }
+    return files;
+}
+const REJECTED = "The user doesn't want to proceed";
+const INTERRUPT = "[Request interrupted by user";
+// IDE context (<ide_opened_file>…), command tags and command output arrive as complete tag blocks before the text.
+const stripLeadingTags = (s) => s.replace(/^\s*(<([\w-]+)[^>]*>[\s\S]*?<\/\2>\s*)+/, "");
+const resultText = (c) => typeof c === "string" ? c : Array.isArray(c) ? c.map((i) => (typeof i?.text === "string" ? i.text : "")).join("") : "";
+// One record → zero or more events (spec › Inputs, › Not a user message). Unknown shapes yield nothing.
+function toEvents(r) {
+    if (r.isSidechain === true || typeof r.uuid !== "string")
+        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 content = r.message?.content;
+    if (r.type === "user") {
+        const injected = r.isMeta === true || r.isCompactSummary === true; // compaction summaries are written by Claude Code
+        const typed = (raw) => {
+            const text = stripLeadingTags(raw).trim();
+            return injected || text === "" || text.startsWith("<") ? [] : [{ ...base, kind: "user_text", text }];
+        };
+        if (typeof content === "string")
+            return typed(content);
+        if (!Array.isArray(content))
+            return [];
+        const signals = content.flatMap((i) => {
+            if (i?.type === "text" && typeof i.text === "string" && i.text.startsWith(INTERRUPT))
+                return [{ ...base, kind: "user_marker", text: i.text }];
+            if (i?.type === "tool_result" && i.is_error === true && resultText(i.content).startsWith(REJECTED))
+                return [{ ...base, kind: "tool_rejected" }];
+            return [];
+        });
+        // IDE extensions and pasted images store a typed message as blocks: join its plain text blocks.
+        if (content.some((i) => i?.type === "tool_result"))
+            return signals;
+        const text = content
+            .filter((i) => i?.type === "text" && typeof i.text === "string" && !i.text.startsWith(INTERRUPT) && !i.text.trimStart().startsWith("<"))
+            .map((i) => i.text)
+            .join("\n");
+        return [...signals, ...typed(text)];
+    }
+    if (r.type === "assistant" && Array.isArray(content)) {
+        return content.flatMap((i) => {
+            if (i?.type === "tool_use" && typeof i.name === "string")
+                return [{ ...base, kind: "assistant_tool_use", tool: i.name, input: i.input ?? {} }];
+            if (i?.type === "text" && typeof i.text === "string")
+                return [{ ...base, kind: "assistant_text", text: i.text }];
+            return [];
+        });
+    }
+    return [];
+}
+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);
+        }
+        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 };
+}

package/dist/types.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export const Event = z.object({
+    kind: z.enum(["user_text", "user_marker", "tool_rejected", "assistant_tool_use", "assistant_text"]),
+    uuid: z.string(),
+    sessionId: z.string(),
+    cwd: z.string(),
+    ts: z.string(),
+    text: z.string().optional(),
+    tool: z.string().optional(),
+    input: z.record(z.string(), z.unknown()).optional(),
+});
+export const Signal = z.enum(["rejected", "interrupt", "phrase", "revert", "repeated"]);
+export const Correction = z.object({
+    uuid: z.string(),
+    sessionId: z.string(),
+    cwd: z.string(),
+    ts: z.string(),
+    text: z.string(),
+    norm: z.string(),
+    signals: z.array(Signal),
+});
+export const Group = z.object({
+    id: z.string(),
+    members: z.array(Correction),
+    representative: Correction,
+    count: z.number(),
+    sessions: z.number(),
+    projects: z.number(),
+    days: z.number(),
+    lastSeen: z.string(),
+    score: z.number(),
+    signals: z.array(Signal),
+});
+export const Suggestion = z.object({
+    id: z.string(),
+    text: z.string(),
+    status: z.enum(["new", "ignored"]),
+    matchedRule: z.string().optional(),
+    count: z.number(),
+    sessions: z.number(),
+    projects: z.number(),
+    days: z.number(),
+    score: z.number(),
+    lastSeen: z.string(),
+    examples: z.array(z.string()).max(3),
+    signals: z.array(Signal),
+});
+export const Report = z.object({
+    scannedSessions: z.number(),
+    skippedLines: z.number(),
+    corrections: z.number(),
+    suggestions: z.array(Suggestion),
+});

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@globalmpc/nomore",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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.",
+  "keywords": [
+    "claude-code",
+    "claude",
+    "claude-md",
+    "ai-agents",
+    "developer-tools",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/globalmpc/nomore.git"
+  },
+  "homepage": "https://github.com/globalmpc/nomore#readme",
+  "bugs": "https://github.com/globalmpc/nomore/issues",
+  "type": "module",
+  "bin": {
+    "nomore": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "mine": "tsx scripts/mine-issues.ts"
+  },
+  "dependencies": {
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}