mohammadhijjawi97/since-cutoff
v0.5.0MIT
Find which dependency APIs your code uses changed after your coding model's training cutoff, and write short AGENTS.md notes from the API diff, each with its source.
Changelog
Unreleased
- Add a technical report on whether the dependency block that
syncwrites pays for its tokens (research/dependency-block-study: the paper and its PDF, de-identified per-run data, the protocols and the analysis scripts; summary in docs/research.md, linked from the docs site's nav, and a short "Research" section in the four READMEs). Over 1,607 agent sessions, the block saved cost only on Opus 5.5 (main study 0.80 of no block), the header alone did about as well, and in real agent contexts the block costs about 0.4% of a context but is repaid by the affected contexts alone (at a fixed saving per affected context) only once 14-49% of them need a changed API (measured: 0.8-7%), so its effect on the other contexts decides. No code changes. sync --header-onlywrites only the block's header: the packages whose API changed since the release they are compared from, each with its pinned version and that release, and the instruction to follow them ("Where these lines conflict with what you remember, follow these lines."), with no change lines. The header is the full block's word for word, so the block is the one the benchmark's header-only arm used (the full block with every-line removed). The meta line records"header_only": true, so later syncs keep it;--no-header-onlywrites the change lines again, and sync says the switch once, not as notes dropped or added package by package. With no--scopeand no block yet, a header lists the packages the code imports.sync --jsongivesheader_onlyandpackages(package lines) for each target, andstatus --jsongivesheader_only. The MCP toolproject_changestakesheader_onlyand then returns that header's Markdown for the imported scope instead of its usual report.sync --profile evaluatedselects the configuration the benchmark measured:--scope importedwith up to 5 APIs per package. Another--scopeor--per-packagewith it is an error. The default scope staysused; the README says what each choice costs, and that the measured release (0.4.1) compared from the release at the cutoff (--cutoff-margin 0).- A package whose sources the running Python cannot parse could not be checked, and the scan
says so, instead of reporting no changes: on Python 3.10, numpy 2.5.4's
__init__.pyi(PEP 695typestatements) and 2.3.1's (a PEP 646*tuple[...]in a subscript) failed to load with a debug log only, and the scan said numpy had no breaking changes. numpy is now among the dependencies that could not be checked, with the reason "Python 3.10 cannot parse numpy 2.3.1's and 2.5.4's sources; run since-cutoff with Python 3.12 or later to check it", andscan --fail-onfails on it (exit code 3): numpy may well have changed, and a CI job on 3.10 would pass what fails on 3.13. This holds for a release's top-level module or stub, a public module in the syntax of a newer Python, and a private one in it that a public name leads to (scikit-learn 1.9 definesLogisticRegressioninsklearn/linear_model/_logistic.py, which hascoefs_paths[0, :, *best_index, :]). Newer syntax is read from the whole statement that fails, from PEP 750's t-strings and PEP 758'sexcept A, B:back to PEP 646's star in a subscript (one split over lines included) and PEP 701's f-strings, and a release whose Requires-Python excludes the running Python is in newer syntax whatever its line shows. Python 2 code (except ValueError, e:,print "row", f(a, *rest)) is not: the package is checked, and the module is said to be left out. The other modules left out (private ones in newer syntax, ones in no syntax the running Python knows) are said in one warning per package, and a distribution read next to a release for itsfrom x import *that the running Python cannot parse (numpy, next to scikit-learn and matplotlib) leaves out only the names taken from it, in the re-export warning. A diff that left anything out is cached for the running Python only, and so is the map of what a package's functions return, which the scan types the project's values with: on Python 3.10 numpy's was empty, and a scan on 3.13 with the same cache then missedx.resize(...)on an ndarray. Nothing is cached for a package that could not be checked, and a diff a newer Python cached is served as before. - Quotes in the notes keep the library's code whole: pandas'
read_csvnote readpandas 2.3.0 said: "Use 'sep=\s+''' instead" For ..., fromUse ``sep='\\s+'`` instead. A reStructuredText literal is one code span with its backslashes unescaped (`sep="\s+"`), code that names something the pinned version has stays code, other code is in quotes, or as it is when it holds a quote itself (huggingface-hub's "check the 'auth' key", scipy'snorm(A, 'fro')), the leading "." of a Sphinx relative name goes, and a quoted sentence ends with a period unless since-cutoff cut the text there. A quote stops before a sentence it cannot make clean (a backtick no span closes), and a replacement stated directly in it is named all the same ("Usepolars.concatinstead."). A replacement stated directly is quoted with the rest of its sentence when that says how, up to 200 characters (polars' "useDataFrame.unpivotinstead, with 'index' instead of 'id_vars' and 'on' instead of 'value_vars'", which the note cut to "UseDataFrame.unpivotinstead."), and a deprecation message that says more than "deprecated" is quoted (fastapi'sORJSONResponse: "FastAPI now serializes data directly to JSON bytes via Pydantic ...", which--allprinted and the note left out), after any sentence of it that gives advice (sqlalchemy 2.1's "Seeany_andall_functions for modern use.", not its "... are deprecated for removal, along with the PG-specific ... functions."). - More notes name the replacement the library's own text gives (diff schema 22: 0.6.0 is not
released). The body of a
.. deprecated::directive is read after a blank line too (pandas'DataFrame.applymap: "UseDataFrame.mapinstead."), and the docstring an@Appendertemplate gives a function (read_csv(date_parser=): "Usedate_formatinstead, or read in as 'object' and then applypandas.to_datetimeas-needed."); a sentence with a{klass}placeholder that a decorator fills at import is left out (pandas'NDFrame.backfill). A name the member's class no longer has is found on its public subclasses, each one's named (NDFrame.swapaxes: "UseDataFrame.transposeorSeries.transposeinstead."). A removed member of a deprecated class with no text of its own quotes the class's, as the class's and naming no replacement (llama-index-core'sReActAgent.from_tools: 'OnReActAgent, llama-index-core 0.12.45 said: "ReActAgent has been rewritten and replaced by llama_index.core.agent.workflow.ReActAgent." [diff]': that class has nofrom_tools), and never a sentence of the class's about another of its members; a removed class quotes the first of its methods whose text names something, as that method's (huggingface-hub'sHfFolder: 'OnHfFolder.get_token, huggingface-hub 0.33.1 said: "This method is deprecated in favor ofhuggingface_hub.get_token..."'). Their notes pointed at the releases page before. Therun --comparebaselines read the old text as 0.3 did (template_hintkeeps it where it differs), so that their blocks, and the numbers measured against them, stay as they were. - Add a reference for environment variables, files and exit codes, with a docs drift check
(docs/reference.md, #69). The check fails when the code reads a variable the page has no row
for (
os.getenvand a constant for the name included), or the page has a row for one the code no longer reads. - Notes from the diff say what to use instead in more cases, and point somewhere useful when they
cannot (an audit of 36 libraries found 25 of 36 notes ending in "since-cutoff found no
replacement in X's deprecation text", several although the text named one; #14). A replacement
the library states in a sentence that leads up to it is named, in the library's own words:
llama-index-core's "FunctionCallingAgent has been rewritten and replaced by newer agents based
on llama_index.core.agent.workflow.FunctionAgent" and huggingface-hub's "['Repository'] is
deprecated in favor of the http-based alternatives implemented in [
HfApi]" (the doc markup dropped) are quoted, tagged[diff + library]; "renamed to X" and a sentence-initial "Use X." count as well. A cue in the sentence that names the deprecated API (else the first sentence) wins over a later "use ... instead" ("oldwas renamed tonew. If you need the legacy behaviour, usecompatinstead." namesnew), and otherwise the strongest cue anywhere in the text ("seeHelperfor the background. Usenew_funcinstead." namesnew_func). "see X" and advice ("Usestrict=Falseto keep the previous lenient parsing") are quoted under[diff], not taken as replacements. Where the text names nothing, the note points at the package's changelog for the changes since the comparison release ("See https://github.com/encode/httpx/blob/master/CHANGELOG.md for the changes since 0.27.2.": the Changelog URL in its PyPI metadata, else the releases page of the GitHub repository its Source, Repository or Homepage URL names; never a sponsors or organisation page, pydantic-core's first URL beinggithub.com/sponsors/samuelcolvin), and says "found no replacement" only when PyPI lists none of them. The pointer named the pinned version at first, which misled: anthropic 1.13.0's notes cited 1.13.0 for what 1.0.0 removed, and the diff does not say which release made a change. The cached PyPI metadata now keeps a package's project URLs, summary and home page (PyPI.project_urls,PyPI.summary); a copy cached before is fetched again once, and read as it is when PyPI cannot be reached, without asking PyPI again for the rest of the scan. - A function deprecated in one call form only (a PEP 702
@deprecatedon one@overload) is named by the parameters that form alone takes (diff schema 21,call_form_only): mcp 2.2's note read "Servercalled as__init__(self, name: str, *, version: str = ..., ...)is deprecated", a 400-character signature, and labelled everyServer("x")call "uses this API"; it reads "Server(...)withon_set_logging_level=,on_roots_list_changed=oron_progress=passed as keyword arguments is deprecated", and a call is in the old form only when it passes one of them. When one of the form's own parameters cannot be passed by keyword (cachetools' positional-onlyinfo, a**kwargs), the note, the terminal heading and--allquote the form's signature instead, when it is at most 120 characters, and otherwise say that one call form (an overload) is deprecated. The task and note prompts quote that description: they are prompt version 3, sorundoes not reuse tasks or answers cached under version 2. - A removed parameter of an SDK method that still takes
extra_bodypoints there alone (the note namedextra_querytoo, which is for query fields, and then said it found no replacement): "If the API still needs them, pass them through itsextra_bodyargument." - Bullets that say the same of several APIs of one package merge into one in the block (#5):
anthropic 1.8's three bullets for
Anthropic.completions,anthropic.AI_PROMPTandanthropic.HUMAN_PROMPTare one ("… were removed; do not use them."), and huggingface-hub'shf_hub_download()andsnapshot_download()share one. The terminal, report.md, the MCP tools and the JSON keep one entry per API (report.md's sources name every API of a merged bullet), and therun --comparebaselines are unchanged.synckeeps a[type-checked]note next to the merged bullet of the other APIs, and counts bullets that merged as changed, not dropped. - A dependency first released after the cutoff that the code imports gets a note, tagged
[metadata], whichsyncwrites and the scan counts as ready: "httpx2 first appeared on PyPI on 2026-05-11, after the cutoff; the model has no training data on it. The project pins 2.13.1 (released 2026-09-23). Summary: The next generation HTTP client. Changelog: https://github.com/pydantic/httpx2/blob/main/src/httpx2/CHANGELOG.md". The scan said its whole API was newer than the cutoff, andsyncwrote nothing. One first released within the margin before the cutoff gets the note too, which says so ("first appeared on PyPI on 2025-07-15, within 30 days before the cutoff; the model has little or no training data on it"), andsyncdrops the note once the code no longer imports the package ("first released 2025-07-15, within 30 days of the cutoff, and your code no longer imports it"). One whose comparison release was an empty placeholder existed, but not its API, and its note says that ("zensical's latest release by 2025-07-01 (0.0.0) was an empty placeholder; the model has little or no training data on its API"), not that it "first appeared on PyPI after the cutoff". The headline counts these apart ("1 dependency's latest release 30 days before the cutoff was an empty placeholder"), not among the dependencies that "did not exist yet", and so does the MCPproject_changesanswer ("only an empty placeholder by that day: 1", under a heading of their own). - The comparison release is the latest release published at least 30 days before the model's
training cutoff, not at the cutoff itself. A model's training data lags its stated cutoff, so
it knows the last weeks before the cutoff least: llama-index-core 0.13.0, which removed
ReActAgent.from_toolsandFunctionCallingAgent, was uploaded on 2025-07-30, the day before claude-sonnet-4-5's cutoff, and a scan of a project pinning 0.14.25 said the code used none of the APIs that changed; it now reports both removals.--cutoff-margin DAYS,SINCE_CUTOFF_CUTOFF_MARGIN, the MCP tools'cutoff_marginand the action'scutoff-margininput set the margin; 0 compares from the cutoff itself, as before. The model line says both days ("training cutoff 2025-07-31, comparing from releases up to 2025-07-01"), and so do the reports,results.json(compare_from,settings.cutoff_margin, also insync --jsonandstatus --json) and the notes block's header and meta line, sostatusandsync --checkreport a block compared from another day as out of date. A block written by an earlier since-cutoff compared from the cutoff itself and is reported out of date untilsince-cutoff syncrewrites it (--cutoff-margin 0keeps the old comparison). The block's package line says which release the notes compare from,**anthropic 1.8.0** (compared from 0.56.0); it said "0.56.0 at the cutoff", which the margin made false, and both forms are read. A dependency first released within the margin counts as new to the model, and the scan, the MCP tools andsyncsay it was "first released 2025-07-15, within 30 days of the cutoff", not "after the cutoff"; one the model knows is "the latest release 30 days before the cutoff". The rest of the text that called the comparison release "the release at the cutoff" says what it is: the GitHub annotations ("fastapi 0.115.14 is the comparison release (the latest one published at least 30 days before claude-sonnet-4-5's training cutoff, 2025-07-31)"; with--cutoff-margin 0, "was the latest release at" as before), the dependency tables' column ("compared from", was "at cutoff"), the old-form legend ("valid for the comparison release") and the MCPproject_changesanswer ("as the comparison release allowed"), an empty placeholder release ("the comparison release 0.0.1 was an empty placeholder", and in the tables that, not "first released after the cutoff", as for one first released within the margin), the progress line ("released after their comparison release", was "cutoff version"),sync --help, the skill and the Codex plugin's description. What changed is said to have changed after the day the comparison releases were published by, not after the cutoff: "Your code uses 2 APIs that changed after 2025-07-01, 30 days before claude-sonnet-4-5's training cutoff (2025-07-31)", "7 of 9 dependencies changed their API after 2025-07-01, 30 days before the cutoff", and the same in the Markdown summary,sync,--fail-onand the MCP answers ("API changed after 2025-07-01 (30 days before the cutoff)";api_changes: "no release on or before 2025-07-01"), since a release within the margin is older than the cutoff (openai 1.93.0 -> 1.98.0 shipped before it). A cutoff given with--cutoffis "the cutoff given for claude-sonnet-4-5", not its training cutoff, and a margin of 1 is "1 day", not "1 days". In the docs, the README's table of the sample project gives its versions 30 days before the cutoff, as the Quick start does (openai 1.93.0, 24 breaking changes; 331 breaking changes in all), and the "How it works" diagram says "Release 30 days before the model's cutoff" in every language.--fail-on changesand the action'sfail-on-changesfail when a dependency "changed its API since the release it is compared from (by default the latest one published 30 days before the cutoff)", asscan --help, action.yml, the READMEs' action table and exit codes and docs/reference.md now say (they said "after the cutoff"), andstatussays the same of a file with no notes. A test fails on a message, a tool description, the skill, a plugin manifest or docs/reference.md that calls the comparison release the release at the cutoff ("release at the cutoff", "cutoff version", "on or before the model's training cutoff"), but in the text of a margin of 0, and on a report or MCP answer for a scan with a margin that says "at the cutoff" or "changed after the cutoff". - A module that takes its names from another distribution with
from x import *is compared with that distribution read next to the release: mcp 2.3.0'smcp/types/__init__.pyisfrom mcp_types import *(mcp requiresmcp-types==2.3.0), and the report had no entry undermcp.typeswhile mcp-types had renamed every field to snake_case, sotypes.Tool(name=..., inputSchema=...)broke unreported. The sibling distribution is downloaded at the version the project locks (or the newest its requirement allows on the comparison date, for the comparison release), under the usual download limit and cache, and its names are compared under the paths that re-export them (mcp.types.Tool.inputSchemaremoved). Only a star import that runs counts: not one in a docstring, a function or anif TYPE_CHECKING:block. An object a release only re-exports from elsewhere is now compared too, where griffe stops at the alias: a class's members (inherited ones included), a function's parameters and a change of kind, reported under the re-exporting path. When the sibling cannot be downloaded, the scan, the report and the MCP tools warn that changes to those modules are not reported. Cached diffs are keyed on the siblings read, and on the source schema, with the diff schema; which distributions each release star-imports is kept in the cache, so a cached diff is still served from the pinned release alone, with nothing else to download. - README: a newcomer now sees, in order, what it is, how to install it (uvx, pipx, pip), a
Quick start on the sample project with the real
scanoutput and the blocksyncwrites, when to use it and what it does not do, then the existing sections. New FAQ: the training cutoff against the release date, what is sent where, why some notes name no replacement, AGENTS.md and CLAUDE.md, the notes' cost in tokens, offline use. The counts come from this release's scan, comparing from 30 days before the cutoff (331 breaking changes and 24 new deprecations in public APIs, and 139 changes to internal ones, in the sample project). The Chinese, Spanish and French READMEs follow the same structure, and now also describe the Gemini CLI model detection andsync --json, which only the English README had. - Docs site: index.md and ai-stack.md describe 0.5.0 (scan, sync, status, pre-commit, the Action and the MCP server) and ai-stack.md's counts come from a re-run with 0.5.0; a nav bar links the pages and the GitHub docs (#67); the link-preview text no longer says "verified AGENTS.md notes" (#51); benchmark.md says it is the study as run with 0.4.1's notes.
- README (all four languages) and how-it-works.md: the intro, the Quick start, "The problem",
the MCP and
[diff]tables, thesyncand block descriptions describe the comparison release as the latest release published at least 30 days before the model's training cutoff by default; they still said "on or before the cutoff". - The READMEs'
api_changesexample is the real output with the default margin (huggingface-hub 0.28.0 -> 2.0.0, 104 breaking changes); it showed the output at the cutoff itself (0.29.1, 98) under a call withoutcutoff_margin=0. They also say that Gemini CLI reads GEMINI.md, and AGENTS.md only whencontext.fileNamein its settings.json lists it. - Docs site for 0.6: index.md (English, Spanish, French) says what 0.6 does (the comparison
release and its margin, typed receivers,
**kwargs: Unpack[TypedDict], the library's own replacements and the pointer for the changes since the comparison release, public and internal changes, the warnings for what the diff cannot see, AGENTS.md and CLAUDE.md,sync --json,models --jsonand--makers, the[run]extra, start-up and thecachecommands), and the nav bar links the troubleshooting guide. ai-stack.md is re-run with 0.6, comparing from 30 days before each cutoff and counting public changes only (Claude Opus 5.5: 23 of the 36 libraries with a public API break, was 20), and its table gives the comparison date.examples/ai-stack/stack_report.pycounts public changes, names the version and the margin under the chart, and no longer reads a stack.json it wrote as a scan. docs/img/scan.svg is made again, with the note that points at huggingface-hub's releases "for the changes since 0.33.1". scripts/check_versions.pychecks the pre-commitrevand the action'ssince-cutoff-versiondefault in all four READMEs (the Spanish and French pins and the translated action tables were not checked).- A changed method is found when the code never names its class: the receiver of a method
call is typed from the pinned release's own annotations, read statically with griffe and
cached per release (a new
receiversfolder in the cache).df = pd.read_csv(...)is aDataFrame,df.groupby(...).count()aDataFrameGroupBy.count, and a class counts with its base classes across the pinned packages, sollm.predict(q)on aChatOpenAIis langchain-core'sBaseChatModel.predictin a file that never imports langchain-core. With pandas 3.0.6,df.applymap(str),df.swapaxes(0, 1)anddf.groupby("key", axis=0)on a frame frompd.read_csvwent unflagged; a scratch project pinning pandas 3.0.6 and polars 2.0.0 went from 4 APIs used to 10. A method a class defines itself is its own, not its base's:DataFrame.sumstill takes positional arguments whereNDFrame.sumno longer does. - Where the receiver cannot be typed, a method whose name is exactly one changed API's across
the packages the code uses, and neither a common Python name nor a member of a built-in or
standard-library type, can count by its name alone. Such name matches are hidden from every
report, the notes,
--fail-onand--annotateunless--include-name-matches(scan,sync) orinclude_name_matches(MCP) asks for them; they are then tagged[name match].scan(the terminal, report.md and the--markdownsummary),syncand the MCP toolproject_changessay how many places they hid ("2 uses matched by name alone are hidden; --include-name-matches shows them";include_name_matches=trueover MCP; run's report.md namessince-cutoff scan --include-name-matches, asrunhas no such flag), and nothing when there is none;results.json,scan --jsonandsync --jsonhave it asname_matches_hidden. A call passing two removed keywords is one place; with blocks written for different cutoffs, sync says which file each count is for. - A class that became a function, or the reverse, is no longer "old form" at a call site: with
pandas 3.0.6,
with pd.option_context("mode.copy_on_write", True):was labelled old form althoughoption_contextis called the same way as a class and as a function. The call is "uses this API", and old form only when it passes a keyword the new signature does not take; a subclass or anisinstance()of it stays old form. The note still says to check the new signature. --base-urlwins overOPENAI_BASE_URLforopenai:<model>, as a flag wins over the environment for every other setting (#94). The variable overrode the flag; the order is now the flag, thenOPENAI_BASE_URL, thenhttps://api.openai.com/v1.- With both AGENTS.md and CLAUDE.md and no block yet,
syncandrun --applywrite the block to both files when CLAUDE.md does not import AGENTS.md, and to AGENTS.md alone when it does, is not UTF-8 or is a link to AGENTS.md (#13): Claude Code reads only CLAUDE.md unless it imports AGENTS.md with@AGENTS.md, and Codex, Cursor and Copilot read only AGENTS.md. CLAUDE.md is read as Markdown, as Claude Code reads imports: not inside a code span (which ends with its paragraph, so a stray backtick does not hide a later import) or a fenced block (```or~~~, closed by a fence of the same character at least as long), and after a byte order mark. The block went to AGENTS.md alone, where Claude Code never saw it.scan,sync,run --applyand nowstatus(its text andstatus --json;status --hookstays quiet) say "CLAUDE.md does not import AGENTS.md, so the notes go to both files: to keep one copy, add a line@AGENTS.mdto CLAUDE.md and runsince-cutoff unapply --target CLAUDE.md", andsync --jsonhas it astip. When both files have the block and CLAUDE.md then imports AGENTS.md, they say "CLAUDE.md imports AGENTS.md, so its since-cutoff block is a second copy of the notes: runsince-cutoff unapply --target CLAUDE.mdto keep one". A block already in AGENTS.md alone stays the only one, with the tip that Claude Code does not read it, now also fromstatus. - A model that models.dev lists several times, by its maker and by gateways and resellers,
takes the cutoff of the requested provider's own listing when it has one, also under the
provider's own spelling (
cloudflare-workers-ai:@cf/meta/llama-3.2-3b-instruct,nvidia:meta/llama-3.2-3b-instruct); else of the maker's own listing, for a dated snapshot without a cutoff the maker's model (claude-sonnet-4-20250514takesclaude-sonnet-4's, not a gateway's cutoff for the dated id); else the earliest cutoff among the listings that have one, whichever route's spelling of the id is asked for (#87). The maker's entry for a new model often has no cutoff yet while gateways' and resellers' have, and they disagree (Qwen3.5-397B-A17B: 2025-01 to 2026-01):opencode/glm-5.1, Together's and DeepInfra's GLM-5 and the routes of Qwen3.5-397B-A17B stopped with "models.dev has no knowledge cutoff", and an earlier cutoff gives more notes, the safe side. The model line names a listing that is not the maker's ("from models.dev, deepinfra's listing"), as do the MCP tools, andsince-cutoff models <id>ends with the listing--model <id>takes. A model the maker does not list is found in the gateway's or reseller's own listing by its bare id: Amazon Bedrock'sqwen.qwen3-coder-480b-a35b-v1:0, Cloudflare's@cf/meta/llama-3.2-3b-instruct, OpenRouter'saion-labs/aion-rp-llama-3.1-8b.metais no longer an alias ofllama: models.dev has a providermetaof its own (Meta's Muse Spark models), a maker whose listing is preferred and whichmodels --makerslists; Meta's Llama API staysllama. since-cutoff modelstakes--json(#25):{"source": ..., "models": [...]}, each model withprovider,id,name,family,training_cutoffas models.dev writes it,cutoff_dateas since-cutoff uses it andreleased, in the table's order, whether or not stdout is a terminal.--makerslists only the model makers' own entries, without the gateways and resellers that list the same ids.- The MCP tool
api_changescarries the "older copy from the cache" warning also in its reply that a package had no release by the cutoff: the copy may not know an older release either. That reply was built before the check. - A metapackage is reported as information, not as a failure, saying what the scan did with
each of its parts: "llama-index 0.14.25 is a metapackage with no API of its own; checked like
any other dependency: llama-index-core; not checked, as the project depends on them only
through other packages: llama-index-embeddings-openai, llama-index-llms-openai and nltk
(--all-deps checks them)" on a line of its own in
scanandrun, with a•insyncand as a bullet of the MCPproject_changesanswer, in place of "1 of 3 dependencies could not be checked: llama-index 0.14.25 is a metapackage without code of its own: it installs ...; check those packages instead". A part the project depends on but the scan could not check ("could not be checked: llama-index-core", its reason given with the others) or--only/--excludeleft out ("left out by --only/--exclude") is not called one the project does not depend on, and the--all-depshint is given only for parts the lockfile or environment pins, inscanandrunwithout--all-deps(syncand MCP have none). The table cell no longer names every part again, norscan --all's summary panel the line. At most 5 parts are named per clause ("and 154 more" for pyobjc 11.1);results.jsonlists them all under the package'smetapackage. Its row in the dependency tables reads "metapackage (no API of its own; 1 of 4 parts checked)", compared from "-", and it is in no count of dependencies, in the terminal as in the MCP answer: "1 of 2 dependencies could not be checked" and "app · 2 dependencies (1 not checked) and 1 metapackage" (the terminal said "1 of 3" and "3 dependencies"). A project whose only dependency is a metapackage (llama-index, docling, pydantic-ai, griffe 2) no longer fails with "No dependency could be checked (... is PyPI reachable?)", and its reports say "No API to compare: the only dependency is a metapackage" instead of "0 of 0 dependencies changed their API" (scan --all, report.md, the Markdown summary) or "0 dependencies checked" (the terminal, and the heading of MCPproject_changes, which also drops its line of zero counts). sync --json's help says it needs--yes,--checkor--dry-run, and the README that stdout stays empty whenever sync fails, not only on a usage error.- basedpyright, which only
runuses, is an extra:pip install "since-cutoff[run]", oruvx --with basedpyright since-cutoff run. With the Node.js it brings it was 180 of the 196 MB an installation took, paid as well byscan,sync,status, the MCP server, the Action, the pre-commit hooks and the plugin, none of which run it. Without it,runstops before the scan and the model calls with the install line; it used to fail at the first probe, after the scan. Thedevdependency group installs it. since-cutoff --help,--versionandcachestart in about 150 ms instead of 400 (Python 3.13; 140 instead of 340 on 3.10): the CLI imports the engine, the API diff, the reports and rich only in the commands that use them.status --hook, which the Claude Code plugin runs at every session start, no longer loads rich or the reports either; what it still pays for is the project's imports, which the hash of the dependencies is made of.since-cutoff cache infoprints where the cache is and, for each kind (PyPI metadata, sources, diffs, model output, ...), its size, its entries and files, and the oldest: when its oldest entry was written, or for the sources, which record their use, when the least recently used tree was last used.cache clear --sources,--diffsand--pypiclear one kind and leave the model's answers torun, which cost money, alone (#30).- The extracted package sources, the bulk of the cache (4 GB on a machine that scanned many
projects), are capped:
SINCE_CUTOFF_CACHE_MAX_MB(default 2048; 0 for no cap). After a new version is extracted, the least recently used trees are removed until the sources fit, never a tree the running scan uses or one used in the last hour, which another process may be reading. Trees extracted by earlier versions are measured once, at the first extraction after upgrading, which may remove many at once: the first removal in a run prints one line with how many trees and MB went (the rest are in the--debuglog), as later scans download them again. A value that is not a number (infandnantoo) gives a warning and the default. sync --jsonreports proposals and write results for scripts, with progress on stderr. It requires--yes,--checkor--dry-run, never prompts, and preserves sync's exit codes.- Check each downloaded wheel or sdist against the sha256 that PyPI lists, skipping the package with a clear error on a mismatch without caching.
- Without
--model, Gemini CLI's model is detected fromGEMINI_MODEL, then the project's.gemini/settings.json, then the user's settings; both string and nestedmodel.nameforms are supported, and unknown aliases are reported instead of guessed. - Bare and routed Qwen, Kimi, GLM and Llama model ids are recognised as their model makers (Alibaba, Moonshot AI, Z.ai and Llama), so cutoff lookup prefers first-party entries over reseller listings.
- The MCP server has two prompts,
check_projectandbefore_upgrade, that ask the agent to call the existing read-only tools; listing them needs no network or API key. --helpand--versionpiped into a reader that goes away (since-cutoff --help | head -1) end with exit code 141 and no traceback also when stdout is unbuffered (PYTHONUNBUFFERED, set in many containers). argparse wrote them itself, past the check for a closed pipe: Python 3.10 printed aBrokenPipeErrortraceback and exited with 1, and 3.11 and later exited with 0.- With griffe 2.3.1 or later, a parameter dropped from a function that still takes
**kwargs(f(x, verbose=False)becomingf(x, **kwargs)) was reported as removed, a breaking change, although calls that pass it still work. griffe 2.3.1 changed how a parameter's kind prints, and the check for**kwargsread that text instead of the kind's name. - PEP 702's
@deprecatedimported through a library's compatibility module (from pkg._compat import deprecated, where_compatimports it fromtyping_extensionsor, on Python 3.13 and later,warnings) is reported as PEP 702's (#44). It was taken for the library's own decorator, whichrundoes not probe because type checkers do not report it, and was missed on an@overload. Diffs cached by earlier versions are recomputed once (diff schema 20). - When PyPI cannot be reached (no network, a timeout, 429 or 5xx after the retries), a package's release list cached more than 12 hours ago is used instead of failing, and the scan and the MCP tools warn from which day each such copy is: releases published after it are unknown (#54). A version the older copy does not list is reported as missing from it, not from PyPI. A 404, or any other answer from PyPI, is still an error.
- A module that the pinned release ships compiled, with no
.pysource and no.pyistub (fast.py->fast.cpython-312-x86_64-linux-gnu.so, or a compiled module that lost its stub), is no longer reported as removed, nor is what it defines or a name a readable module still imports from it (#52). Since only sources are extracted, the diff could not tell it from a removal. A name a readable module stopped importing from it is still removed. A top-level package whose__init__is compiled hides only the names it defines; a compiled subpackage__init__hides that subpackage, since griffe cannot enter a directory without an__init__.pyinside a regular package, and the scan warns. The source tree now records the compiled modules (extension modules in wheels,.pthdirectories included, and Cython.pyxfiles without a.pyin sdists), and the scan, the report and the MCP tools warn that changes to such a module, private ones included, and to the names taken from it are not reported. After upgrading, cached sources are downloaded and extracted again once (source schema 3) and cached diffs are recomputed (diff schema 21). - The API diff is the same on every machine: griffe read a package's sibling modules in the
order the file system lists them, so an object that several of them import from a private
module took its public path from that order. mcp 1.28.1 -> 2.2.0's switch to
httpx2had 20 places instead of 23 wheremcp.client.streamable_httpcame beforemcp.client.sse: onlyssestill importsMcpHttpClientFactory, so its__call__(timeout,authand its return) did not match between the releases. Modules are now read in the order of their names (diff schema 21, with the notes' evidence below). - Cached API diffs are keyed on the installed griffe's version too: griffe reads the sources and
is a range dependency, so after an upgrade the diffs the old one made are made again instead
of served from the cache.
results.json,scan --json(settings.griffe_version,report_schema3) and report.md record which griffe it was. Diffs cached by an earlier since-cutoff are made once more (and diff schema 21 would make them again anyway), so the mcp switch above shows its 23 places there too. - Notes name the replacement a library's warning gives in more cases. A message built before its
warnings.warncall (message = (...), thenwarnings.warn(message)) is read, a replacement the text states in quotes counts like one in backticks, and every alternative it gives is named ("Use a, b, or c instead"): httpx 0.28's note now says "Client()no longer acceptsproxies; do not pass it. Useproxyormountsinstead ofproxies. [diff + library]", where it said it found no replacement, and click 8.2'sBaseCommandandMultiCommandnameclick.Commandandclick.Group. - A parameter in the place of a removed one, with its type, is no longer a "probable rename"
when a version note in the pinned release's docstring (
.. versionadded::,.. versionchanged::) says the new one was added or the old one removed: click 8.2'sCliRunnertookcatch_exceptionswhere 8.1 tookmix_stderr, and the note told agents to passcatch_exceptions, which changes what the runner does. scripts/record_diff_fixtures.pyre-records the real diffs intests/fixtures/diffsfrom PyPI, after a diff schema bump for example;--checkonly says which would change. Two new golden pairs, httpx 0.27.2 -> 0.28.1 and click 8.1.8 -> 8.2.0, pin what their changelogs document and the notes an agent gets for them (tests/test_golden_diffs.py).- A parameter removed behind
**kwargs: Unpack[SomeTypedDict](PEP 692) is reported (#60). pandas 3.0'sread_csvandread_tabletake their keywords through**kwds: Unpack[_read_shared], and griffe takes a**kwargsfor any keyword, so the loss ofdelim_whitespace,date_parser,infer_datetime_format,keep_date_colandverbosewas not reported. The TypedDict's keys (its bases' included) are now compared like the signature's names, in both directions: a key of the old TypedDict the new signature does not name is a removed parameter too. A bare**kwargsstill takes anything, and so does a TypedDict that allows other keys (PEP 728'sextra_items=orclosed=False);selfandclsare no keywords, so a method made static or a class method is not a change (diff schema 21). - A change to a method is matched under the public classes that inherit it without overriding
it. pandas 2.3.1 -> 3.0.6's
NDFrame.fillnalostmethod, and the change carried onlypandas.core.generic.NDFrame.fillna, a path no code calls, sodf.fillna(method="ffill")on aDataFramewas not a use and the change never reached the report. The change now lists the inheriting classes' paths (pandas.DataFrame.fillna) inimport_pathsandalso, and the scan matches calls on them. A change to a method of a private class (pkg._base._Base .fillna) that a public class inherits, never reported before, is reported under the shortest public inheritor (pkg.DataFrame.fillna), as a folded removal is. - An attribute a class set in a method at the cutoff and may get from a base in another
package in the pinned release is unknown, not removed. fastapi 0.143.0's
Param(pydantic .fields.FieldInfo)no longer assignsself.deprecated; it putskwargs["deprecated"]and callssuper().__init__(**use_kwargs), so pydantic may set it, and the scan reported it as removed. since-cutoff does not read other distributions, so when the new constructor hands the name to the base's (by name, in position, through a**kwargs, or by having no constructor of its own) the scan, report.md and the MCP tools warn once per package that the class's attributes were not compared, next to the compiled-module warning. A field or constant of the class body (a pydantic model'susage: int), an attribute the constructor neither sets nor hands on (0.143.0'sAPIRoute.secure_cloned_response_field), a method the class dropped and a key dropped from aTypedDictare still removed. An attribute the new class sets where griffe does not look, in a tuple target (self.dependant, _ = ...) or in a function of its module givenself(0.143.0's_populate_api_route_state(self, path, ...), which setsroute.path,endpoint,nameandmethods), is not removed. - The counts tell public APIs from internal ones. fastapi 0.116.1 -> 0.143.0 scanned as "35
breaking changes", 9 of them helpers such as
dependencies.utils.get_flat_dependantand 34 paths toBaseModelWithConfig.Config; uvicorn's wereloops.*,config.LOOP_SETUPSandmain.HTTP_CHOICES. Each change now has atier: public when the package's top level exports the API (afrom .m import *there that copies it from a module re-exporting it on purpose counts:anthropic.AnthropicBedrock), a module names it in__all__or re-exports it asfrom .m import X as X(anthropic.types.CompletionCreateParams), or it is documented (a value made of a function,convert = deprecated(...)(_convert), with the function's docstring; a member with its class; a method a public class inherits is public), else internal. The headline counts,scan --all, the Action summary and the MCP tools' totals count the public changes and give the internal ones once as "+N internal"; the dependency table's breaking column gives them as "19 (+3)";scan --internal(which implies--all) andinclude_internal(MCP) list them; report.md lists them after the public ones; results.json andscan --jsonkeep every change (internal_changesnext tobreaking_changes).api_changes(symbol=...)matches the symbol against every change and lists the internal ones when they are all that match: a question about an API asks for its changes. The notes are not affected: they cover the APIs the code uses. - The pip block of a conda environment file (
environment.yml, elseenvironment.yaml) is read like a requirements file (#3, started by @wufangyong973 in #10):- pip:underdependencies:declares the packages pip installs from PyPI, with their pins (anthropic==1.8.0), ranges and extras; a conda project failed with "no dependencies found". A file it includes (-r requirements-x.txt,--requirement ...) is read too, relative to the environment file as conda has pip read it, with its own includes; one that does not exist gets a warning ("the pip block of environment.yml includes requirements-x.txt, which does not exist"), and an include of a file already read is not read again. In any requirements file, an include is now followed with or without a space after-rand with a space or=after--requirement, its name being the first word after the option, as pip reads it (-r base.txt --preincludes base.txt;--require-hashesis no include), and one of a name the system cannot hold,-r a<NUL>b, is skipped like a missing one (Python 3.10 stopped with a traceback). A pip block that YAML aliases repeat (- *e) is read once, and no more than its first 10,000 lines are read, with a warning. The conda packages around it (python=3.12,numpy=1.26) are not read, as they do not come from PyPI (--debuglists them), nor are other options (-e .), local paths and bare git URLs; a direct reference (pkg @ git+https://...) is not looked up on PyPI. A version pinned there, or in a file it includes, is labelled with the environment file ("environment.yml pins 1.8.0"), as one thatrequirements.txtincludes is withrequirements.txt, also next to a.venv: the versions then come from ".venv, environment.yml for 1 not in it" when the environment lacks one. Arequirements*.txtthat the pip block includes and that is also read on its own keeps its own label. A lockfile still wins over its pins, with the usual warning when they disagree. A file that is not YAML stops the scan in one line ("could not parse environment.yml: ... (line 3, column 4)"), also next to a lockfile, as apyproject.tomlthat is not TOML does; "no dependencies found" names the pip block among what is read, says when the environment file has no package in it, and names an included file that does not exist. The pre-commit hooks, the Action's cache key and the README's workflowpaths:takeenvironment.ymlandenvironment.yamlinto account. PyYAML 6.0.1 or later is now a dependency (6.0 does not install on Python 3.12 and later).
0.5.0 - 2026-09-28
- The skill's
allowed-toolsincludesince-cutoff unapply, which its steps already tell the agent to run to remove the notes (found in a catalogue's review of the skill). - The skill's frontmatter keeps to the six fields of the Agent Skills spec, which claude.ai
uploads and the Skills API enforce ("Unexpected key(s) in SKILL.md frontmatter:
argument-hint"):
argument-hintis gone (Claude Code still hands the skill the arguments of/since-cutoff:since-cutoff scan, now without the$ARGUMENTSplaceholder, a Claude Code feature the spec does not have), the author and the version are strings undermetadata(scripts/check_versions.pychecks the version with the other release fields), andcompatibilityhas no backticks, which skill catalogues read as shell substitution. The body has the sections those catalogues look for: Overview, Prerequisites, Instructions (the steps as before, plussync --scope importedwhenscansuggests it), Output (what is written where, and what each tag says was checked), Error Handling (with the exit codes ofsyncandstatus), three Examples and Resources.skills-ref validatepasses; the tons-of-skills marketplace grader gives it 92/100 (A, from 73, C), its remaining errors being the top-levelversion,authorandtagsthat the spec does not allow. - A dependency the pinned version switched is now a change of its own (DIFF_SCHEMA 19,
dependency_switched, tagged[diff + metadata]): openai 3.x, anthropic 1.8, huggingface-hub 2.0 and mcp 2.2 requirehttpx2and no longerhttpx, and their public signatures takehttpx2objects; code that hands themhttpxclients or timeouts, or catcheshttpx.HTTPErroraround huggingface-hub's calls, is flagged with where it does so. A diff of the package's own API showedhttpxonly inside other changes' signatures. The diff reads both releases' Requires-Dist (the wheels' METADATA, already stored with the sources) and, only when the pinned release dropped a requirement, where the public API names that library's types: a switch needs places (parameters, returns, attributes, base classes, re-exports) that named the dropped library's types and name the types of another library the release requires, or of a copy of the dropped one it ships, the same type names at half of them or more, and no trace of the dropped library left in the pinned public API. Measured with the first version of the rule (base requirements only) on 283 real release pairs: 16 switches (httpx->httpx2in openai, anthropic, huggingface-hub and mcp;requests->httpx2orhttpxin huggingface-hub, litellm and gradio) and none of the rewrites a looser rule counts (crewai's langchain -> pydantic). - The rule also covers a requirement dropped from an extra both releases define ("fastmcp-slim
4.0.10's
client,mcpandserverextras requirehttpx2instead ofhttpx"), a copy of the dropped library the package ships ("typer 0.27.2 no longer requiresclickand shipstyper._clickinstead", with typer's own names to use:typer.BadParameter,typer.Context), and a library the older release already required ("gradio 4.28.3 no longer requiresrequests; its API nameshttpxtypes instead"). A private module named after the dropped library that imports it is a shim, not a copy: langsmith 0.7.1 -> 0.14.1 stays no switch. A switched parameter is counted by the type it names now (openai 3'shttp_client: 8 signatures takehttpx2.Client, 6httpx2.AsyncClient), a constructor is recorded under its class's path and a classmethod or staticmethod under its class's (fastmcp.FastMCP.from_openapi), each switched parameter with its position in the call. - The note is one or two sentences of at most 300 characters: "openai 3.19.2 requires
httpx2instead ofhttpx:OpenAI(http_client=...)takeshttpx2.Client(httpx2.AsyncClientforAsyncOpenAI),OpenAI(timeout=...)takeshttpx2.TimeoutandOpenAI(base_url=...)takeshttpx2.URL. Usehttpx2there, nothttpx." The Requires-Dist entries, how many places switched and more of them (with how many other signatures name the same type) are in a "Places:" line ofscan --alland report.md, and in the MCP tools. - Code uses a switched dependency in the old form only where a file hands the package a value
that reads the old library: by keyword or by position, at a switched parameter of a switched
constructor, function, or classmethod or staticmethod called on its class
(
OpenAI(http_client=httpx.Client()), orOpenAI(http_client=c)afterc = httpx.Client()or withc: httpx.Client;hf_raise_for_status(httpx.get(url)), the way huggingface-hub's own code calls it;FastMCP.from_openapi(spec, client=httpx.AsyncClient())), or by catching a switched type of it around a call into the package. Reading its names or importing it next to the package is "uses this API":OpenAI(timeout=30.0)next to an unrelatedhttpx.getorhttpx.Client()hands nothing over, and an old object passed to an instance method is not counted. The switch comes first insync --scope imported,scan --alland the MCP tools (a new first section, "Dependencies switched", inapi_changes, whosesymbolmatches the libraries, the switched type names, parameters and callables), andrundoes not probe it yet. The terminal, report.md, the MCP tools and the JSON add an "Installed:" line (whether the project's lockfile or pins, or else its virtual environment, transitive distributions included, still have the old library,used_apis[].installed; 12 of the 36 pins of the AI stack example requirehttpx) and a "Runtime:" line pointing to where the pinned source still names it (openai/_httpx2.py:27; a name a module only exports, in__all__, a module-level__getattr__or__dir__, is not one, nor is a package name in a list of requirements or a documentation example, such as fastmcp 4'sField(examples=[["fastmcp>=2.0,<3", "httpx", "pandas>=2.0"]])): what a library does with the old objects differs (openai 3 converts some, anthropic 1.8 raisesTypeError, according to their sources), so the note does not say. - The header of the notes block explains
[metadata]when a note has it: "the two releases' declared requirements (Requires-Dist in their wheels' METADATA)". A notes block puts a package's switched dependency first, and the "old form" legend says what the pinned release did: "switched to another library for the types it uses". - README: the Results list links the benchmark (360 Claude Code sessions, since-cutoff 0.4.1's notes against Claude Code alone on the 17 post-cutoff tasks: cost ratio 0.80, 95% CI 0.70-0.90) to its write-up and repository, with the Context7 arms' quota caveat.
0.4.1 - 2026-09-28
- A parameter removed from an SDK method that still takes
extra_bodyorextra_query(anthropic, openai and other Stainless-generated clients) no longer gets "do not pass them": "Messages.create()no longer acceptstemperature,top_kortop_pas keyword arguments. If the API still needs them, pass them through itsextra_bodyorextra_queryargument." The parameter left the signature, which a static diff can see; whether the API still takes the field, it cannot. In the benchmark pilot, every agent given the old note followed it and dropped thetemperature=0its task asked for. The diff records which of the two a removed parameter's method takes (DIFF_SCHEMA 17,request_extras), because the recorded signature is cut at 400 characters and anthropic 1.8'screate()is longer. sync --scope importedputs first what an assistant writing new code against a package is most likely to run into: import paths that no longer work (a module or package that moved, a name the package exported at its top level that was removed), then changes with a known replacement (one the library's own text names,[diff + library], or a rename or move the diff checked,[diff + move checked]), then removals of public classes and functions, then parameters removed or now required and members removed, then deprecations. The changesscan --all, the Markdown summary and the MCP toolproject_changeslist per package follow the same order. Measured on mcp 1.28.1 -> 2.2.0, the five notes were parameter removals onClientSession,add_response_router,McpErrorandmcp.client.experimental; they are nowMcpError->MCPError, themcp.server.fastmcppackage ->mcp.server.mcpserver,FastMCP->MCPServer,streamablehttp_client(the library namesstreamable_http_client) andClientSession.list_prompts(cursor=)(the library namesparams). Theusedscope keeps its ranking.- A subpackage whose modules all moved to one new parent (three of them, or every module that
left it), leaving nothing public behind, is one change in the notes and in the scan: "The
package
mcp.server.fastmcpmoved tomcp.server.mcpserver; import from there. [diff + move checked]", in place of one note per module. The individual moves stay in results.json. Code that imports anything from the old package uses the change. The diff records, on each module's move, how many public names the old package still has in the new version (move_evidence.left_behind; 0 for mcp 2'smcp/server/fastmcp.py, a shim with no API): a module that stayed makes no change of its own, so the moves alone could not tell, and a package with a module left behind is not moved whole (from pkg.a import wstill works; the modules that left are listed each on its own, and that code uses no change). - The diff finds a class or function that came back under another name (DIFF_SCHEMA 16): a new
object in the same module, or in the module the old one moved to, that keeps the old one's
public members (at least 80% and at least 5, or all of fewer than 5; a name that differs in
case alone with every member kept) and that alone does. The note says both names: "
FastMCPis nowMCPServer:mcp.server.FastMCPmoved tomcp.server.MCPServer; import it withfrom mcp.server import MCPServer. [diff + move checked]". Not for a tiny class, for a type of fields alone unless the names are related, when two candidates qualify, when the candidate existed before, or when the library's own text names the replacement (that stays[diff + library]). A class keeps a member only when it defines it itself or inherits it from a base the old class did not have: a new sibling subclass of the same base, which inherits what the old one overrode, is not the rename (a module of handlers or resources dropping one subclass and adding another). Names unrelated to the old one need five such members (Task->Workeronrun,closeandstartis none). On anthropic 0.115.0 -> 1.8.0, huggingface-hub 1.21.0 -> 2.0.0, openai 2.44.0 -> 3.19.2, pandas 2.3.2 -> 3.0.6 and langchain-core 0.3.72 -> 1.6.5 it finds none; on mcp 1.28.1 -> 2.2.0FastMCP->MCPServer(29 of 30) andMcpError->MCPError. Cached diffs are computed again. - A module-level name bound to a method of an instance the module makes (huggingface_hub 1's
api = HfApi()andduplicate_space = api.duplicate_spaceinhf_api.py) says which method (alias_of, DIFF_SCHEMA 16) and takes the method's deprecation text. When both went, the notes and the scan list them as one API, under the name: "huggingface_hub.duplicate_spacewas removed; do not use it. UseHfApi.duplicate_repoinstead. [diff + library]", where--scope importedwrote "found no replacement" for the name and cut the method's note, which named it, at the budget; code using either form uses it. On huggingface-hub 1.21.0 -> 2.0.0 three of the five default notes now name the library's replacement. - Within a tier of the
--scope importedorder, classes, functions and modules come before a name that is only no longer re-exported (the object is still there, in a module below the one it was imported from: langgraph 1'slanggraph.pregel.merge_configsislanggraph.pregel.main.merge_configs; such a move ranks with removals, after them, not as a known replacement) and before constants and type aliases (anthropic 1.8'sAI_PROMPT,ProxiesTypes;from anthropic import HUMAN_PROMPTbreaks too, but the modules that moved out ofanthropic.types.betacome first). sync --per-package 0is rejected ("must be 1 or more"): it silently meant the default.- New
sync --per-package N: how many APIs--scope importednotes per package (default 5); a package moved whole counts as one. The block records a choice other than the default, and later syncs keep it, as with--suggestions. - When
synchas no notes to write, it says how many changes--scope importedwould write, and for how many packages.
0.4.0 - 2026-09-28
- New
since-cutoff syncwrites the notes from the API diff for the changed APIs your code uses into a since-cutoff block in AGENTS.md (or CLAUDE.md), and keeps them in step: run again after a lockfile or code change, it adds notes for newly used APIs, checks a bumped package again, and drops the notes of a package that is no longer a dependency, is no newer than the release at the cutoff, or whose changed APIs your code no longer uses. It prints a unified diff of the file first and asks before writing (--yeswrites without asking; without a terminal to ask in, it writes nothing and exits with code 3). Text outside the block keeps its bytes, CRLF line breaks included. No model is called. synckeeps the model and cutoff the block was written for (so teammates whose agents use other models do not rewrite it back and forth), unless--modelor--cutoffis given;--model a,buses the earliest of their cutoffs and names both. It keeps a[type-checked]note thatsince-cutoff run --applywrote, in place of the note from the diff for the same API, while its package keeps the same version and the code still uses that API (the block's meta line records which API each such note is about); after a version change the note from the diff takes its place, and sync says thatsince-cutoff run --only <pkg>tests the model again (it does not suggestrun --apply, which writes a block of that run's notes alone). When the notes are unchanged, the block is left exactly as it is, even if another since-cutoff version wrote it. A block 0.3 wrote is upgraded, keeping its model.sync --checkwrites nothing and exits with code 3 when the notes are out of date, and says why ("AGENTS.md is out of date: anthropic 1.8.0 in the notes, 1.9.2 in uv.lock; ...");--dry-runshows the diff and exits with 0. A block edited by hand is not replaced:syncshows the diff and exits with the new code 4 unless--forceis given. When a package the notes are about cannot be checked (PyPI unreachable),syncwrites nothing (exit code 1). A bullet whose API had one before is counted as changed ("toylib 2.0: 1 changed"), and aftersync --forcereplaces a hand edit, sync says only that.- The block does not depend on which of an API's changes the code uses: a note lists its
parameters in the order of the old signature, and a package's notes are in the order of
their APIs. Code that starts or stops passing a removed parameter no longer rewords the note
(so
sync --check, the pre-commit hook and the Action'scheck-notesno longer fail on unchanged facts). sync --scope importedalso notes the changes most likely to matter in each changed package your code imports (up to 5 APIs per package), for code that uses none of the changed APIs yet;sync --suggestionsadds the similar names, tagged[not confirmed]. The block records both, and the nextsynckeeps them.- New
since-cutoff statussays, without the network, whether the notes are current for the lockfile: per package, the version the notes are for and the one the lockfile has; whether other dependencies changed (the block's hash of them); and where the versions come from, naming every file ("the versions in requirements-dev.txt, requirements.txt"). Exit code 3 when a block is out of date assync --checkwould find it offline, including a block that since-cutoff 0.3 orrun --applywrote, which sync rewrites; not when there is no block, which a project whose code uses no changed API never gets (sync --checksays whether notes are needed). When the model your coding agent is set up with has an earlier training cutoff than the notes (they may then miss changes),statussays so with thesync --modelcommand for it; that is not a failure, since sync keeps the block's model.--jsonfor scripts.--hookprints one line only when the notes are out of date, and always exits with 0. - The Claude Code plugin runs
since-cutoff status --hookwhen a session starts, so the session is told when the notes are out of date (the first time, uvx downloads since-cutoff). The plugin installs from the repository, so this hook ships with the release that hasstatus: until then it waits inhooks/hooks.json.in, andscripts/check_versions.pyfails a release before 0.4.0 that hashooks/hooks.json, and one from 0.4.0 on that does not. - New pre-commit hooks:
since-cutoff-syncupdates the notes when a lockfile, requirements file, pyproject.toml, AGENTS.md or CLAUDE.md changes (it fails by changing the file; withargs: [--check]it only checks), andsince-cutoff-status, the offline check. - The GitHub Action's new
check-notesinput runssync --checkand fails the job when the notes are out of date or were edited by hand; the newnotesoutput says which. For a project with no block yet, it checks against thecutoffinput too, as the scan does. - The notes go where a block already is:
run --applyandsyncupdate the block in AGENTS.md and in CLAUDE.md, whichever has one, instead of adding a second block to AGENTS.md when the first was written to CLAUDE.md. A first block goes where it did in 0.3 (AGENTS.md, or CLAUDE.md when only that one exists); issue #13 covers projects with both. Until then, when the notes go to AGENTS.md and there is a CLAUDE.md that does not import it,scanandsyncsay "CLAUDE.md does not import AGENTS.md, so Claude Code does not read the notes in AGENTS.md: add a line@AGENTS.mdto CLAUDE.md". - The block is appended after a blank line, also to a file whose last line has no line break
(the meta line records the line break since-cutoff added, and
unapplytakes it away again, byte for byte). A file that ends right after the end marker, without a line break, stays so and is up to date (sync --checkfailed on it for ever). A byte order mark before the start marker (Windows editors) is read and kept:sync,statusandunapplyfailed with "unbalanced or repeated since-cutoff markers".--targetinto a folder that does not exist creates it, and a file that cannot be written is an "error: cannot write ..." (exit code 1), not a traceback. The header puts only file names in code spans ("the versions inpyproject.toml, latest on PyPI for 3 unpinned"). scansays "2 notes ready:since-cutoff syncwrites them to AGENTS.md and keeps them in step with uv.lock.", and, when your code uses none of the changed APIs of a package it imports, suggestssince-cutoff sync --scope imported. That scope skips, among the APIs the code does not use, a params class's field that mirrors a parameter a callable lost (anthropic'sMessageCreateParamsBase.temperature) and an internal hook, one of whose parameters has a type private to the library (sqlalchemy'sMappedColumn.declarative_scan_for_composite).- Without
--modeland with no model setting,scanandsyncsay they use the training cutoff of Claude Code's default model (they said "this tests", asrundoes). A warning of the scan (an ignored lockfile) is printed once, not two or three times. - The block's hash of the dependencies (
deps) counts a dependency nothing pins by its declared range, not by PyPI's latest release, so thatstatuscan compute it offline. scanleads with your project: "Your code uses 2 APIs that changed after claude-sonnet-4-5's training cutoff (2025-07-31)", then, per package ("anthropic 0.60.0 -> 1.8.0 (0.60.0 was the latest release at the cutoff; uv.lock pins 1.8.0)"), each changed API your code uses: what changed, "old form" or "uses this API", the files that use it (at most 3;-vlists all), its note with the tag, the "Runtime:" line and the names that merely look similar. Then how many notes are ready, what the labels and tags mean, and one line for the rest: "Also changed, not used by your code: 326 changes in 7 packages (huggingface-hub 144, ...).--alllists them."scan --allprints 0.3's summary panel, dependency table and top changes per package after that first section. A dependency first released after the cutoff that your code imports gets its own line, with the date of its first release. No model is called and no API key is needed, as before.- "Old form" means the code uses the API as the release at the cutoff allowed and the pinned release no longer does: it reads or imports what was removed, moved (its old path) or changed kind, uses what is deprecated, or passes a removed or deprecated parameter by keyword. It is a static name match; nothing is run. A parameter that is now required, keyword-only or positional-only is always "uses this API" for now.
- Where the code uses an API is shown per file for now (
app/main.py); line numbers are issue #8.FileUse.file(the file's path relative to the project, with "/"),selection.uses()andselection.form()are the interface they will extend. - The Markdown summary (
scan --markdown) starts with "Your code uses N APIs that changed after the cutoff" and a table (where, API, change, form, replacement), with each file linked on GitHub whenGITHUB_REPOSITORYandGITHUB_SHAare set (under the project's folder inGITHUB_WORKSPACE), then the notes block, folded ("2 notes ready for AGENTS.md (since-cutoff syncwrites them)"). Each package's list of changes is folded now; it was open for packages with changes your code uses. - report.md starts with "## Used by your code" (each used API with the files, the note, the
runtime caveat), and each change your code uses under "All changes found" says where:
"· used in
app/main.py". - results.json and
scan --json:report_schema2;used(counts of APIs, changes, old-form uses, files, packages, and the new packages the code imports); eachused_apisentry gainsform,used_in,locations(file, kind, names, form, match;line,columnandcodestay null until lines are recorded),locations_totalandreplacements(every one the note names, each with what it replaces;replacementis the first), and each of its changes aform.used_apis[].versions_fromnames the file that pins the package (pyproject.toml) where it said "pinned". A package first released after the cutoff hasfirst_releasedinscan. Nothing 0.3 wrote was removed. - The MCP
project_changesanswer starts with "## Your code uses these changed APIs": each used API with the form, at most 3 files, its note, the runtime caveat and the similar names, not confirmed as replacements; within the same size limit as before. scan --fail-on changes|used|old-formexits with code 3 when a dependency changed its API after the cutoff, when your code uses a changed API, or when it uses one in the old form, and says why ("Exit code 3: --fail-on old-form: your code uses 1 changed API in the old form").--fail-on-changesstays, as--fail-on changes.--fail-oncan be given more than once (--fail-on used --fail-on old-form: either fails).scan --annotate githubprints GitHub Actions annotations: a warning on each file that uses a changed API in the old form, a notice on the others, escaped as the Actions toolkit does. They go to stdout, so--annotatecannot be combined with--jsonor--markdown -(exit code 2).- In a log or a pipe, a diff served from the cache no longer prints "diffed 3/8 (openai)": a warm scan goes from "Diffing the API of ..." straight to the results.
- "Your code uses" finds the names a package re-exports.
from huggingface_hub import hf_hub_downloadfollowed byhf_hub_download(..., resume_download=True)is marked, as areimport pkg; pkg.fetch(...)andfrom pkg import Client; Client().send(...)for afetchorClientdefined in a submodule: only the path of the module that defines them counted. A change reached under more than six paths (a method removed from a base class that many classes inherit) is found under every one of them, not only the six the report lists. - "Your code uses" is precise enough for "old form",
--fail-on old-formand the warning annotations. A changed parameter counts only when the file passes it to that callable: to a call of an imported name, of a name read on an imported module or class, or of a method of what the file shows is an instance of the class, or, for a method matched by its attribute name (client.messages.create), at the end of that same chain;temperature=passed to another library'screatein the same file no longer makes anthropic'sMessages.create"old form". An SDK's beta mirror (client.beta.messages.create) is another API than the one outsidebeta: anthropic 1.8.0'soutput_format, removed from the betaMessages.createonly, is no longer said ofclient.messages.create, and a beta note names its module. A removed name is matched under its own paths only:DeprecatedIn37andDeprecatedIn45, both= CryptographyDeprecationWarningin cryptography, are two changes, and code importing one is not reported as using the other. - A change listed once for several (a sync method and its async twin, a beta mirror) is
matched as each of them:
client.messages.create(temperature=...)marks it even when the one listed isAsyncMessages.create. A constructor call counts under every name of its class:AsyncClient(timeout=...), or the name a package re-exports the class under. - The API diff records more about each change, in results.json and
scan --json:import_paths(every public path that leads to the changed object, re-exports included; results.json andscan --jsonlist the shortest 5 andimport_paths_total, since a method of a base class can have thousands),hint_source(where the old version's deprecation text comes from),move_evidence(how many public names or parameters a moved object kept, which is how the move was checked) and, for a removed parameter that the new version still reads by name in a decorator,still_handled_at(huggingface_hub/utils/_validators.py:187forhf_hub_download(resume_download=...)in huggingface-hub 2.0.0, which drops the argument with a warning instead of raisingTypeError) andstill_handled_text, what that code says of it ("deprecated without replacement"). - A removed parameter's deprecation text is also read from its own docstring entry
(huggingface-hub 1.21.0's
text_generation(stop_sequences=...): "Deprecated argument. Usestopinstead.") and from the old version'swarnings.warntext (hf_hub_download(resume_download=...): "... If you want to force a new download, useforce_download=True."). The--compare templatenotes leave these out, so they stay what 0.3 wrote and results stay comparable. The MCP tools say "the old version warned" before awarnings.warntext. - Diffs cached by earlier versions are recomputed once (diff schema 14). A change without import paths (from an older diff, or made by hand through the Python API) is matched by package and name: a path of the same package ending in the same name counts, and the mark says "matched by name".
- The MCP
api_changestool finds a change under any of its paths (symbol="M7.legacy"for a method removed from the base class ofM7). scanwrites notes from the API diff, with no model and no API key, for every changed API your code uses: one bullet per API, with all its changes (Messages.create()no longer acceptstemperature,top_kortop_p; the parameters in the order of the old signature). The terminal shows each under its API; report.md has them under "Notes for AGENTS.md (with their sources)";scan --jsonand results.json have them underused_apis(package, versions, the changes, the replacement and the note with its tags, the versions it applies to and what was checked) andnotes_preview(the block, its size and the filessyncwould write it to).- Each note carries a tag that says what was checked, and a replacement is named only with
evidence:
[diff](the static comparison of the two releases' public APIs; "do not pass it", and "since-cutoff found no replacement in anthropic's deprecation text", which is what it read, right after what it is about; or, where the library's own text says so, "huggingface-hub's deprecation text says there is no replacement forresume_download", read also in what the pinned release's code that still handles the parameter says of it);[diff + library](the replacement is named in the library's own deprecation text, a docstring,@deprecatedmessage orwarnings.warn, and exists in your pinned version: huggingface-hub 1.21.0 -> 2.0.0'stext_generation(stop_sequences=...)says "Usestopinstead ofstop_sequences", sourced "huggingface-hub 1.21.0 huggingface_hub/inference/_client.py"; text that only mentions a name as advice, as hub 0.34.3's "If you want to force a new download, useforce_download=True" does, is quoted under[diff]and is no replacement, in the note, results.json or the Markdown table);[diff + move checked](a moved object that keeps the old one's public names or parameters);[diff; probable rename](a parameter in the same position, with the same type, under a new name: a guess, labelled as one). A note written by the model inrunis[type-checked]. A replacement that is a method is named as the note names its API ("UseBaseChatModel.invokeinstead."); a quote is whole sentences, without those that only say "deprecated" or ask to open an issue, or none; the same sentence is not said twice. A stubs package's note (pandas-stubs,types-*) says what its declarations no longer have and that type checkers reject it, not that the runtime no longer accepts it. - Names that merely look similar are never written into the notes. The terminal, report.md
and the MCP tools show them as "similar names in 2.0.0, not confirmed as replacements"
(0.3 said "similar parameters now" in MCP and "(now
x?)" in the reports), and not at all where the library says there is no replacement ("deprecated without replacement"). A parameter the diff found renamed in place reads "probably renamed tostart(same position and type)". - When your pinned version's source still reads a removed parameter by name, the terminal,
report.md and the MCP tools add a "Runtime:" line: huggingface-hub 2.0.0 still handles
force_filename,local_dir_use_symlinks,proxiesandresume_download(huggingface_hub/utils/_validators.py:178-203), so calls passing them may run with a warning while type checkers reject them. It is not written into the notes, whose advice ("do not pass it") is the same either way. - The notes block has a new format (2). Its first line is unchanged, so 0.3's
unapplystill removes it. A meta line follows with the model, cutoff, the file the versions come from, a hash of the dependencies and a hash of the block's own text (so a hand edit shows), and the header says what the tags mean, names the real file the versions come from (uv.lock, not "requirements"), says "No library code was run", and each package line gives the version the notes apply to and the release at the cutoff:**anthropic 1.8.0** (0.60.0 at the cutoff).notes.parse_blockreads both formats back. run: a note whose example does not type-check falls back to the note from the API diff (with its tag) instead of 0.3's one-line template, and the blockrun --applywrites, and measures, is format 2. The--comparebaselines keep 0.3's block and wording exactly, so their numbers stay comparable with 0.3's; the run's own headline numbers are not directly comparable with 0.3's. results.json'snotes_detailgainstags,applies_to,checks(including what the held-out test measured for the note) andreplacement;verifiedstays, meaning the same aschecks.example_type_checks. A fallback note'ssourceis now "diff" (it was "template").- The word "verified" is gone from what since-cutoff prints: the CLI description,
--help, stages ("Writing notes for 4 failures and type-checking their examples", "Testing the notes on 18 held-out tasks"), the report ("type-checked notes", "Notes for AGENTS.md (with their sources)", "Held-out test of the notes"), the package description and the descriptions of the Claude Code, Codex and Agent Plugins manifests and of the skill say what was checked. A dependency first released after the cutoff is "first released after the cutoff" (it was "newer than the model"). The MCP instructions say that packages released after your reported training cutoff may be missing from your training data, and that the tools do not see behaviour changes or runtime shims (they said "trust ... over your memory"). - The API diff records, per change, the names the library's deprecation text gives that exist
in the new version (
library_names), the files the old and new texts were read from (hint_file,deprecation_file) and whether a parameter's suggested new name is a rename in place (renamed); diff schema 13. Diff schema 14 addsstill_handled_text. - Docs: the README starts with what
scanprints for the sample project (the changed APIs its code uses, and the note for each) and one command that needs no API key; the 0.1.0 result card moved to a Results section that says its scope (one project, one model, since-cutoff 0.1.0). New README sections: "Keep the notes current: sync and status", "Measure your model" and "What 'verified' means" (each evidence tag: what was checked and what was not). The CI examples usecheck-notes,sync --check, thesince-cutoff-synchook and--fail-on old-form. docs/how-it-works.md has a section "Notes without a model: scan and sync" (where the code uses a changed API, the note for each API and its evidence, the block and its meta line, sync's rules and exit codes, status), and "Fix and verify" is now "Write and test notes", in the diagram too. PRIVACY.md says that the locationsscanshows stay on your machine and thatrunprompts never contain your code. The Chinese, Spanish and French READMEs say the same.scripts/demo_svg.py scanrenders the new scan output (docs/img/scan.svg).
0.3.2 - 2026-09-27
- A wheel whose METADATA, top_level.txt or .pth file expands to gigabytes no longer fills the memory: as with the sources, only the start of each file is read (they were decompressed whole, and deflate shrinks a gigabyte of padding to about a megabyte).
- A TLS connection that drops in the middle of a download (
ssl.SSLEOFError: EOF occurred in violation of protocol) is retried like any other network error, instead of ending the scan with a traceback. - When the extracted sources cannot be moved into the cache (a virus scanner holding a file on Windows, or another since-cutoff process replacing the same broken copy at the same moment), the dependency is skipped with "could not publish the sources", or the other process's copy is used, instead of the scan ending with a traceback.
- A download that turns out larger than
--max-download-mbsays "is above the 80 MB download limit (--max-download-mb)", as when PyPI lists the size, instead of "network error (response larger than 83886081 bytes)". openai-compatible:<model>works withoutOPENAI_API_KEY, as the README says: a local server (vLLM, LM Studio, llama.cpp) needs no key. It failed with "OPENAI_API_KEY is not set".- A model API that answers with something other than JSON (a web page at a wrong
--base-url, a proxy's error page), or with JSON of another shape ("message": nullor a list of content parts from an OpenAI-compatible server; a list or"content": nullfrom a gateway in front of the Anthropic API), fails that model call with a clear error instead of ending the whole run with a JSONDecodeError, AttributeError or TypeError traceback. - Claude Code calls that stay overloaded or rate-limited fail right after the third attempt, instead of waiting 8 more seconds first.
- A run with a
claude-codemodel no longer leaves an emptysince-cutoff-claude-*folder behind in the temporary directory. --model gpt-4.1-2025-04-14,o3-2025-04-16and OpenAI's other dated snapshots find their model's training cutoff instead of failing with "unknown model" when models.dev does not list that snapshot, and so does an id with both dots and a date (claude-sonnet-4.6-20260101isclaude-sonnet-4-6).since-cutoff unapplygives back the file as it was before--apply, byte for byte: it added a line break after a last line without one, and dropped trailing spaces (a Markdown line break) and blank lines at the end. For that,--applynow puts the block right on the line after a last line without a line break. A block moved into the middle of the file by hand is removed without taking the indentation of the line after it or leaving blank lines at the top of the file.- A hand-edited or damaged uv.lock, poetry.lock, pdm.lock, pylock.toml, Pipfile.lock,
pyproject.toml or Pipfile with a string, list or number where a table or list belongs is
read as far as it makes sense, or refused with "could not parse ...", instead of ending the
scan with an AttributeError or TypeError traceback.
dependencies = "requests"was read as six one-letter dependencies (r,e,q, ...). A uv.lock fork whose markers cannot be compared counts, as other markers that cannot be evaluated do. - With packaging older than 26 on Linux, a requirement marker on the kernel's version
(
platform_release >= '5') no longer ends the scan withInvalidVersion: '6.5.0-1025-azure'. - Code that Python itself cannot parse because it nests too deeply (generated code that joins
thousands of strings with
+), in the project or in a package, is skipped like a file with a syntax error, instead of ending the scan with a RecursionError. - Archive members whose names end in a dot or a space (
pkg./x.py,.../x.py) are left out: on Windows the first overwrotepkg/x.py, and the second made a folder in the cache that nothing could delete. No module or package is named like that. - A model's answer that Python cannot parse, because of a NUL byte (Python 3.10 and 3.11) or code nested too deeply (3.13), counts as an answer without valid code, instead of ending the run with a ValueError or RecursionError, and again on every later run, since the answer was cached before it was read.
# type: ignoreand# pyright: ignorecomments in a model's code are always removed before it is type-checked. After a form feed or a U+2028 character anywhere in the code, they stayed (and another line could be cut short instead), so they could hide the very error the check looks for.- In results.json, the Wilson interval of 0 of n is exactly
[0, ...]and that of n of n[..., 1]: rounding gave 2.8e-17 and 0.9999999999999999, which leave out the rate itself. - MCP
api_changesreads a symbol with one closing parenthesis too many (client.messages.create(model=m))) as the call without it, instead of matching nothing. - A project gets the same versions whatever machine scans it. Environment markers and
uv.lock forks were resolved for the machine running the scan: with
--python 3.11, private-gpt's uv.lock gave onnxruntime 1.20.1 (its Windows fork) on Windows and 1.25.1 elsewhere, and on ARM machines unsloth's declarations for Windows on ARM narrowed the ranges. Markers are now tried for Linux (x86-64), Windows (x64) and macOS (Apple silicon) alike, and of the forks that match, the newest counts. - A poetry.lock or pdm.lock that locks a package once per Python range is read as uv.lock
is: the version for the project's Python (
--pythonor.python-version). With python-poetry's own lock and Python 3.12, rapidfuzz was 3.14.6, the version for Python 3.15 and later, because the last entry won. - The project itself, installed for its tests from a Pipfile (Pipenv names it after a hash:
e1839a8 = {path = ".", editable = true}), is no longer reported as a dependency that could not be checked. - The GitHub Action runs
actions/cachepinned to a commit (v6.1.0), as it already didastral-sh/setup-uv: moving thev6tag can no longer change the code that runs in your workflow.
0.3.1 - 2026-09-27
- The CLI no longer crashes on its own output. On Windows, stdout or stderr sent to NUL (
> NUL, or Git Bash's> /dev/null) crashed every scan with a UnicodeEncodeError on the progress spinner ("lost sys.stderr", exit code 1, which also broke--fail-on-changesin CI), because NUL claims to be a terminal. A file, a pipe or NUL now gets UTF-8 and no live progress bar, and a terminal shows a character it cannot encode as?. When the reader of the output goes away (since-cutoff scan | head), the run stops quietly with exit code 141, the code a shell gives a writer stopped by SIGPIPE, instead of printing a traceback and exiting with 120. - Output to a file, a pipe or a CI log is laid out 160 columns wide (
COLUMNSstill sets the width) instead of rich's default of 80, which cut the panel's subtitle and wrapped every table row. In a narrow terminal, long package names and versions fold instead of squeezing the status and changes columns to nothing, and a subtitle too long for the terminal moves into the panel. A skip reason too long for the table is cut at a word and ends with "..." (it was cut at 80 characters, in the middle of--max-download-mb). - In a terminal narrower than 100 columns the table gives the status its short form
("changed, imported", "new"), the version columns the width their versions need, and the
package names the rest, broken at a "-" (
opentelemetry-/sdk). At 80 columns every changed row took three lines and names broke asopentelemetr/y-sdk. - In a file, a pipe or a CI log, where there is no live progress bar, the diff says how far it got about ten times ("diffed 40/71 (transformers)") instead of nothing for minutes. Wheels are extracted about 40% faster on Windows, where resolving the path of every file took half of the time (each directory is resolved once now).
- SyntaxWarnings about the scanned project's own code ("invalid escape sequence '\W'") no longer reach stderr, in the CLI or the MCP tools.
- A change reachable under several import paths says "also removed under 12 other paths, e.g.
setuptools.command.alias.alias.ensure_string_list" (MCP) or "(also removed under 12 other paths)" (Markdown) instead of "12 similar, e.g. ...", which read like a replacement next to "similar names now" but named another path that lost the name too. - MCP
api_changestakessymbol="Redis"as redis'sRedisclass: the symbol names the package itself only when spelled like its PyPI or import name (redis), and a class name as written (Redis, notlegacy) matches whole path segments, soRedisfindsRedis's changes and notRedisCluster's. Before,RedisandCeleryapplied no filter at all. scan --markdown -prints only the progress and the report's path on stderr, as--jsondoes, instead of the whole console report, which CI logs then showed twice.- Counts of one are singular ("0 of 1 dependency changed its API", "1 dependency was not flagged"); "N more dependencies were not flagged" says "more" only when the table lists others; a single unchecked dependency's reason is no longer "for example"; and the progress line says "Diffing the API of N packages released after their cutoff version" instead of calling them "changed" before the diff has found out. "Checking N dependencies on PyPI" counts only those it looks up, not those installed from git, a path or a private index.
- The version source says where the versions come from. Without a lockfile or environment, it
names the files that pin them (
pyproject.toml,requirements.txt, ...), with "latest on PyPI for N unpinned", or says "latest on PyPI, as nothing is pinned". It said "requirements" even for a pyproject.toml or Pipfile that pins nothing, whose versions were the latest releases on PyPI. Theversion_sourcefield of results.json changes the same way. --all-depswithout a lockfile or virtual environment warns that the transitive dependencies are unknown, so only the declared ones are checked (in the terminal and the reports), instead of silently doing nothing. A requirements file written by pip-compile oruv pip compilecounts as a lockfile: it pins the whole tree.- The output of pip-compile and
uv pip compileis read as such: a pin whose# viaannotation names only other packages (# via kombu) is a transitive dependency, checked with--all-deps, and only those# via -r requirements.in(or via the project'spyproject.toml) are direct; without annotations, the.infile next to it says which. Every pin counted as direct before, so a scan checked the whole tree (84 packages for pypistats.org, whose requirements.in names 17). - A transitive dependency that the project's code imports itself (alembic and sqlalchemy,
pinned "via flask-migrate"; a package only a lockfile lists) is checked without
--all-deps, like a direct one. - A lockfile the project is not set up for no longer overrides the versions its requirements
pin: a poetry.lock or pdm.lock next to a pyproject.toml without that tool's table or build
backend (or a Pipfile.lock without a Pipfile) is ignored when its versions disagree with the
pinned requirements, with a warning that names the first disagreements ("ignored poetry.lock:
the project is not set up for Poetry, and 51 of its versions disagree with the pinned
requirements (alembic 1.4.2 vs ==1.16.4, ...)"), and its lock-only packages are not added
with
--all-deps. A 2020 poetry.lock hid 13 changed packages of pypistats.org, whose requirements.txt pins flask 3.1.1, not 1.1.2. A lockfile the project uses still wins, with a warning about the disagreeing pins. The version source names every place the versions come from ("poetry.lock, requirements.txt for 32 not in it") instead of the lockfile alone. MCPproject_changesshows these warnings under its heading. - A project whose dependencies are only in setup.py or setup.cfg gets an error that says those files are not read and what to do instead (list the dependencies in requirements.txt or pyproject.toml, or install the project into a .venv), and names every file that is read, Pipfile included.
- A dependency installed from git, a URL or a local path is skipped as "installed from
git+https://github.com/org/pkg.git@ref, not from PyPI" (with any credentials removed) instead
of "not installed from PyPI (direct URL)". A git or URL source in uv.lock, poetry.lock or
pdm.lock is named the same way ("installed from
git+https://github.com/pydantic/strict-no-cover@7fc59da2c4df"), not as "installed from git";
a Poetry private index (
type = "legacy") reads "a private index", not "a URL". - A metapackage without code of its own (docling over docling-slim, griffe 2, fastmcp 4, bs4) is skipped with a reason that names what it installs and says to check that instead of "could not find importable modules in ".
- The download-limit message gives the limit as set and the file's size in the same unit: it
said "84 MB" for the default
--max-download-mb 80. - A package that had only pre-releases by the cutoff (sqlgpt-parser 0.0.1a5, betas such as
0.51b0) is compared with the newest of them, instead of being reported as first released
after the cutoff; unpinned, a package with only pre-releases is checked at its newest one,
which pip and uv install, instead of being skipped. A development release (
0.0.1.dev5) is not such a baseline: it is how nvidia-cuda-runtime and its siblings reserved their names in 2021, so they are "newer than the model" again instead of "could not find importable modules". - A release at the cutoff that only reserved the name, with no modules or only empty ones in
small pure-Python files (zensical 0.0.0's empty
__init__.py), makes the package "newer than the model" ("0.0.0 at the cutoff was an empty placeholder"), instead of "no breaking changes" or "not checked". MCPapi_changessays the API is newer than the model's training data. scan --model claude-haiku-4-5works:scanonly needs the training cutoff, so a model id without a provider (or an alias such assonnet) is enough. An unknown model id gets close matches, andrun's hint for a Claude id without a provider namesanthropic:next toclaude-code:.- MCP
project_changesstays under about 24,000 characters: past that, the remaining changed dependencies get one line each under "N more with API changes", with a hint to pass them inonly, and long lists of names end with "and N more" (a project with 155 dependencies got 56 KB). Its heading counts the dependencies checked ("9 of 14 dependencies checked") instead of all of them. The one-line list counts towards the budget too (private-gpt got 25,135 characters). Tools().project_changescalled from a script diffs the packages in-process unless givenTools(processes=True): its worker processes imported the script again, which raised a RuntimeError on Windows and macOS without anif __name__ == "__main__":guard and ran the script once more per worker.since-cutoff mcpstill diffs several packages in parallel.importedin results.json (scan[], and nowpackages[]too) says whether the project's code imports the package, from the package's import names (a namespace package such asgoogle.genaionly when the code imports that part): true or false for the packages whose files were read, null for the others (released before the cutoff, first released after it, or not checked). It was always false. The import names behind it are the ones code imports: a stub-only distribution'spandas-stubsdirectory ispandas(types-requests, types-tqdm, ...); pywin32'swin32\lib\win32coniswin32conandpythonwin\pywinispywin, the directories its.pthfile puts onsys.path(its changes were listed aspythonwin.pywin.*, which cannot be imported); and a distribution with modules in a shared namespace (google-cloud-core'sgoogle/cloud/client.py) is those modules, not all ofgoogle.cloud, whichfrom google.cloud import bigqueryimports.- Every report lists the dependencies in the same order: those whose API changed first, of
those the ones the code imports, then by breaking changes and then deprecations. The terminal
table, its list of changes and report.md used to rank by the number of changes alone, so the
internals of a dev tool the code never imports (mypy, sphinx, coverage) came first, while
--markdownand MCPproject_changesput imported packages first. The terminal table and report.md now also say "imported by your code" in the status, as--markdowndid. - The terminal table and report.md show "breaking" and "deprecated" columns instead of one
"changes" column that counted breaking changes only, was blank for a package with only
deprecations and looked out of order (a package with 2 breaking changes and 7 deprecations
sat above one with 7 breaking changes). The
--markdownsummary lists "you use" before "at cutoff", as the others do, and report.md written byscanleaves out the probed, stale and wrong columns, which are always empty without probes. - "Your code uses X" marks are judged file by file, in the files that import the package, and
under the change's own import path. A module-level name counts only when a file imports it or
reads it on an imported module:
copier.asdictis not theasdictoffrom dataclasses import asdict,typing_extensions.Callablenottyping.Callable,torchaudio.ionot the standardio. A method or attribute counts only when the same file reads it on the class, on what the file shows is an instance of it (app = Starlette(...)thenapp.middleware, a parameter annotated with the class,self.middlewarein a subclass), or on an attribute named after the class (client.messages.create), not on any value in a file that imports the class (self.middlewareof mcp's ownServermarked starlette's removedStarlette.middleware); a constructor only when the class is called; and a changed parameter only when it is passed by keyword to its own callable (subprocess.run(text=True)says nothing aboutVersion(text=...)). Before, any attribute, keyword argument or imported name anywhere in the project matched, which marked (and ranked first) changes the code never touches, in the terminal, in both Markdown reports, under MCP's "Touching names your code uses" and in the choice of changesrunprobes. - A dependency that nothing pins gets the newest release in the range the project declares
(
numpy<2.3,transformers>=4.54,<5) instead of the newest on PyPI, which could be a version the project excludes; with--pythonor a.python-version, only a release that supports that Python.version_sourcein results.json says so ("latest on PyPI matching <2.3"). Pipfile versions (requests = "==2.28.2","<3") and Poetry constraints written as PEP 440 specifiers (">=1,<2") count too; before, every Pipfile entry was unpinned. - A dependency declared several times with environment markers (
typer==0.27.1 ; python_version >= '3.10'andtyper==0.23.2 ; python_version < '3.10') gets the declaration for the project's Python (--pythonor.python-version), or else for the newest Python, as uv.lock forks do; before, the last pin in the files won. Of several pins that apply, the newest wins. A dependency declared from PyPI but also as a direct URL in some extra (torch in a CUDA extra) is checked; only one declared by URL alone is skipped as not from PyPI. - Names that still work are no longer reported as removed. A name the new version still lists
in
__all__of a module that binds names the source does not spell out (typing_extensions bindsCallable,Dict, ... withglobals().update(...), and adds some with__all__.append(...)per Python version) is not removed, which takes typing-extensions 4.12 -> 4.15 from 41 breaking changes to none; a stale__all__entry that nothing binds still is (black 26.5.1'sblib2to3.pgen2.tokenize.generate_tokens). A name a module still hands out through__getattr__or a table of deprecated aliases (click'sBaseCommand,mypy_extensions.NoReturn,anyio.abc.CapacityLimiter, Django'sdjango.core.mail.BadHeaderError), or a class through a metaclass property (urllib3'sRetry.BACKOFF_MAX), is reported as deprecated, with the library's own message or replacement ("useanyio.CapacityLimiterinstead"), or not at all when it is served without a warning. So is a name that the class of a module object swapped intosys.modulesserves: transformers 5's_LazyModulehands out every*TokenizerFastas the tokenizer without "Fast", every name that a module below it lists in__all__(BartTokenizerFast), and a tokenizer its converter table maps to another one (ElectraTokenizerFast). Of the 100*TokenizerFastnames private-gpt got as removed (andRobertaTokenizerFastas "moved to"tokenization_roberta_old), 5 remain (Bloom, MT5, Realm, RetriBert), for which neither the import structure nor the converter table has an entry. A module that re-exports another distribution withfrom other import *(mcp 2'smcp.types, from mcp-types) no longer has every name reported removed. - Stubs are read as type checkers read them. A function declared only with
@overload(the usual case in a.pyifile: numpy'sndarray.partition,cachetools.cached, django-stubs'QuerySet.defer, pytest-django'sassertNumQueries) is no longer reported removed, and names that only a stub next to a module declares reachfrom x import *(qdrant-client'sgrpcpackage: 555 false removals). Imports thatfrom x import *copies without x meaning to re-export them (av.container.Any,yaml.Composer,nltk.corpus.reader.ieer.os,copier.asdict), and names a plain module star-imports for its own use, are not API. - Other names that were never API are left out: names bound only under
if __name__ == "__main__":(rich.diagnose.console, virtualenv'spy_info.argv), values bound only on some paths throughif/tryblocks (torchvision.extension.lib_path,certifi.core.Package), per-module loggers and type variables,TYPE_CHECKINGandVERSION_TUPLEin generated version files, transformers'utils.dummy_*_objectsplaceholders, and griffe'sdde/*placeholder for an unresolved star import. - A member that a class may still inherit is no longer reported removed: from a base in the
standard library (
BatchFeature.keysthroughUserDict,FrozenError.argsthroughAttributeError), or an override that called its base's method when the base comes from another package (starlette'sTestClient.getthroughhttpx.Client), or from a base whose copy the package ships itself (setuptools 80'sCommand.ensure_string_list, fromdistutils.core.Command, which setuptools serves fromsetuptools._distutilson Python 3.12 and later;pkg._vendor.*likewise). A module function that the old version attached to a class (Document.new_page = utils.new_page) and that is now a method of the class is not removed either (58 such changes for pymupdf 1.25 -> 1.27). - Parameter changes: a positional parameter renamed in place is one change, the old name's
removal with the new name as a suggestion, instead of "removed" plus "now required"; a
positional-only one (
/, or the__xconvention: pydantic'smodel_post_init(__context)becoming(context, /)) is not a change.*argsand**kwargsare shown as such ("**kwargswas removed, so extra keyword arguments are no longer accepted") instead ofclose(kwargs=...), and not reported when the new signature names the parameters they took. A function wrapped by a class (typing_extensions'@_TypedDictSpecialForm) keeps its call signature, and the parameters of a pytest fixture, which pytest passes (time-machine'stime_machine_fixture(request)), are not reported. Signatures show/and no longer show*args = (). The console,--markdownand report.md show the new name of a renamed parameter, as MCP did: "parameterposwas removed (nowstart?)". - A deprecation on some overloads of a function is a deprecated call form, not a deprecated
function: "
pydantic.config.with_configcalled aswith_config(*, config: ConfigDict)is deprecated: Passingconfigas a keyword argument is deprecated. ..." (andcachetools.cachedwith a positionalinfo). results.json has the call form incall_form. - Kind changes: a name bound to something callable (
write_pack_index = write_pack_index_v2,Scanned = namedtuple(...), a callable instance,BadHeaderError = ValueError, a stub'sones: Final[_Constructor]) that becomes a function or class, or the reverse, is not a break, nor is an attribute becoming a type alias or a definition that depends on the Python version orTYPE_CHECKING. A value that cannot be called (a literal,Union[...]) still is. - "Moved to" and "similar names now" hints are checked. A move needs the same object, not just
the same name: a class or module that kept its public names (of several such modules, the one
that kept the most, and none on a tie), a function with the old parameters, a value with the
same literal or type expression; never a logger or type variable from another module. The
target is where the object is defined or re-exported, not a module that merely imports it
(
dulwich.protocol.PEELED_TAG_SUFFIX, notdulwich.server). A protobuf message that generated code built withGeneratedProtocolMessageTypeand a newer stub declares as a class of another module moved there (21 of qdrant-client'sgrpc.points_pb2messages, now inqdrant_common_pb2). Similar names are only names new in the same owner and of the same sort (nocollectionsforCollection, no existingDimension.zeroforDimension.is_zero). Objects are reported under their shortest public path (cryptography.hazmat.primitives.ciphers.aead.AESGCM, not a chain of module imports). Diffs cached by earlier versions are recomputed.
0.3.0 - 2026-09-27
runnow exits with code 1 when no API change could be probed (for example because every task-writer call hit a rate limit) or when the task writer failed for at least half of the changes. Before, such a run exited 0, so--fail-on-stalepassed a run that measured nothing.- The held-out result keeps every interval next to the number it belongs to. Before, the 95% CI
of "changes fixed" was printed next to the task-level before -> after rates, where it read as
an interval for those rates. Now the summary shows the task-level rates with the number of
paired tasks and API changes behind them; their difference with a 95% cluster-bootstrap
interval (resampling API changes with all their tasks, 4000 resamples, fixed seed); "changes
fixed: X of Y" with its own Wilson 95% CI, the number of changes broken and an exact two-sided
sign test (changes fixed vs broken); and the held-out pairs that were not counted, by reason
(untouched, off-task, invalid, error). report.md adds a statistics table (held-out tasks and
the regression check side by side) and a table per API change; results.json adds
difference,ci95_difference,sign_test_p,changes_broken,excluded_reasonsandper_change. The printed difference is the difference of the two rates printed next to it (12%->75%is+63), while results.json keeps the exact value. - "Changes fixed" now counts what it says: an API change is fixed when more than half of its
counted held-out tasks are wrong without the notes and correct with them (with one or two
held-out tasks per change, as in
--quickand the default, that means all of them); "broken" is the mirror case. Before, a held-out answer that was already correct without the notes also counted towards a fix. - The regression check (previously-correct APIs) reports the API changes still correct with the
notes (more than half of their pairs correct) with a Wilson 95% CI, and the changes broken;
report.md leaves out "changes fixed" and the sign test for it, which say nothing about changes
the model already got right. In results.json,
heldout.regression.changes_fixedandci95_changes_fixednow count wrong -> right, as for the held-out tasks (so they are about 0); what they counted before, the changes still correct, is nowchanges_still_correctandci95_changes_still_correct. run --tasks-out FILEsaves the tasks a run used (per API change, the probe task first), andrun --tasks-from FILEruns on those tasks instead of calling the task writer; API changes the file does not cover are skipped with that reason. Together they repeat a measurement on exactly the same tasks, for another model or another set of notes. A tasks file may be UTF-8 with or without a byte order mark. Within a change, a task that repeats an earlier one, the probe included (ignoring case, punctuation and spacing), is dropped, as the task writer's repeats are. When failing changes have fewer held-out tasks than--heldoutasks for (a file written with a smaller--heldout, or a task writer that repeated itself), the run says so and records the numbers it used (heldout_usedin the settings; report.md shows "2 asked, 1 used"). The tasks file keeps who wrote the tasks: written again from reused tasks, it names the original task writer, prompt version and tool, and a run on reused tasks records them (tasks_written_by; report.md shows "tasks written by", and the run's own model as the note writer).--tasks-outis checked before any model call (not a folder, not the--tasks-fromfile, which it would shrink to the changes this run probed) and written last, so a failed write keeps the result card, the JSON output and--apply.- results.json (
settings) and report.md ("Run settings") record what a run's numbers depend on besides the answers: the since-cutoff version, the model under test, the task and note model, the Claude Code effort, the prompt version, the API diff schema, the probe, held-out and regression budgets, the Python version, the tasks file (if any) and the date. run --compare template,signaturesmeasures simpler notes next to the verified ones, so a run shows how much the verified notes add instead of assuming they are best.templatestates each failing change in one sentence from the API diff;signaturesgives the new signature and first docstring paragraph of each changed API, or of the replacement its library names. Neither calls a model. Every held-out task and regression check is answered once without notes and once per block, so all blocks are paired against the same answers without notes, and they are compared on the same pairs: a pair counts for every block only when its answer without notes is scorable and no block's answer with notes is an error (so a rate-limit error on the one task a baseline did not fix cannot hand it a "fix"). The verified notes' own result keeps every pair it can count, as without--compare; when errors leave out some of those, the result card adds the verified notes' rates on the shared pairs. The result card adds a line per baseline; report.md adds a table with each block's size in tokens, held-out correct without -> with, the pairs it did not count and why, changes fixed with its 95% CI, changes broken, the regression check, and the changes only the verified notes or only the baseline fixed with an exact sign test; results.json addsarmsand, on each held-out attempt, thearmit saw. Without--comparea run does and reports exactly what it did before.- Without
--model,runandscantest the model your coding agent is set up with.SINCE_CUTOFF_MODEL(a full spec such asopenai:gpt-5.4) always wins. Inside Claude Code (which setsCLAUDECODE=1for the commands it runs) only Claude Code's settings count:ANTHROPIC_MODEL, thenmodelin the project's.claude/settings.local.jsonand.claude/settings.json, then in~/.claude/settings.json, else Claude Code's default; other agents' files are not read. Elsewhere the most specific setting wins: first the agents' environment variables (ANTHROPIC_MODEL,AIDER_MODEL), then every project setting, the nearest folder first, then the user settings. Project settings are looked for from the scanned folder up to the repository root (the first folder with.git), never in the home folder or above: Claude Code's.claude/settings.local.jsonand.claude/settings.json, Codex's.codex/config.toml(with the selected profile, asopenai:<model>), OpenCode'sopencode.jsonoropencode.jsonc, Aider's.aider.conf.yml. User settings, in the same order:~/.claude/settings.json,$CODEX_HOME/config.tomlor~/.codex/config.toml,~/.config/opencode/,~/.aider.conf.yml. Aider's short aliases (4o,flash,gemini,deepseek,r1,grok3, ...) are read as the models they stand for; a model name since-cutoff cannot place stops the run with a message naming the setting, instead of a malformed spec. The model line, report.md and results.json say where the model came from ("model from .claude/settings.json"), and an error about a detected model names the setting. Only the model fields are read. Before, the default was Claude Code's user-level model, andscanguessed Sonnet whenever~/.claude/settings.jsonnamed none, even when the project,ANTHROPIC_MODELor another agent named a model. When no setting names a model, the default is still Claude Code's, and the tool now says so and how to choose another.--model claude-codebehaves as before. - A
--modelwhose provider since-cutoff does not know, such aslmstudio:qwen3-coder, gets a hint to useopenai-compatible:<model>with--base-urlfor a local or custom server. scanlooks up the training cutoff of models from any maker or reseller the model registry knows, such as--model google:gemini-2.5-pro;runsays which providers it can call instead. Amazon Bedrock (us.anthropic.claude-sonnet-4-5-20250929-v1:0) and Vertex AI (claude-sonnet-4-5@20250929) model ids are recognised,claude-code:opusplancounts as Sonnet (the model that writes the code), andanthropic:sonnet(Aider's alias) means the newest Sonnet, reported as an assumption. The MCP tools takeprovider:modelids for any provider the registry knows, such asgithub-copilot:gpt-5.4.runchecks that it can call the model (its API key, or theclaudeCLI) before it scans the dependencies, instead of failing minutes later on the first call.
0.2.0 - 2026-09-27
New
since-cutoff mcp: an MCP server (stdio) with three read-only tools, so any agent (Claude Code, Codex, Cursor, VS Code, Claude Desktop, Gemini CLI) can ask what changed since its training cutoff before writing code:api_changesfor one PyPI package (optionally one symbol),project_changesfor every dependency of a project, andmodel_cutoff. No model calls; package code is only read statically. Adds a dependency on the MCP Python SDK (mcp>=2.0).- The MCP tools say what they return, when to use which, that they are read-only, and how long
a first call can take; each parameter has a description with an example in the input schema,
and
project_changesandapi_changessend progress notifications when the client asks for them.symbolinapi_changestakes a call the way code writes it (client.messages.create, with or without arguments; several separated by commas) and suggests the bare name when nothing matches. - A GitHub Action (
uses: MohammadHijjawi97/since-cutoff@v0): scans the project for a given model, adds a Markdown summary to the job summary, exposes the changed packages and change counts as outputs, and fails only withfail-on-changes: true. Its cache is saved even when that makes the job fail. No model calls. since-cutoff scan --markdown PATHwrites a short GitHub-flavoured Markdown summary (per dependency: the version at the cutoff, the pinned version and the top changes, with changes to names your code uses first);--markdown -prints it to stdout.since-cutoff scan --fail-on-changesexits with code 3 when a dependency changed its API after the cutoff.- A pre-commit hook,
since-cutoff-scan, that runs when a lockfile, requirements file or pyproject.toml changes. - Requests to OpenRouter carry its app attribution headers (
HTTP-Referer,X-OpenRouter-Title,X-Title), which name since-cutoff, not the user.
Packaging and distribution
- The Claude Code plugin starts the MCP server from a root
.mcp.jsonpinned to this release (uvx since-cutoff==0.2.0 mcp), and its manifest no longer hasdisplayName, which Claude Code 2.1.101 rejects. The marketplace entry now has a version, author, links, license, keywords and a category. - Agent Plugins manifests at the repository root (
plugin.json,mcp.json), a Codex plugin manifest (.codex-plugin/plugin.json, withassets/icon.svg), a Gemini CLI extension (gemini-extension.json), and aDockerfileandglama.jsonfor MCP directories. server.jsonand a release job that publishes each version to the official MCP Registry asio.github.MohammadHijjawi97/since-cutoff, authenticated with GitHub OIDC.- The skill asks before
run(it sends prompts to the chosen provider and uses its credits), tells agents other than Claude Code to pass--model provider:model, and mentions the MCP tools. The README shows how to install it in other agents withnpx skills add. PRIVACY.mdandSECURITY.md, and README sections with example prompts and on privacy and support.- The release workflow runs only for full version tags (
vX.Y.Z), fails when any version field differs from the tag (scripts/check_versions.py, which the tests also run), and creates the GitHub release. Thev0tag is moved by hand after a release. - Social preview images for the repository and the GitHub Pages write-up, with the sample size next to the headline number.
API diff
- Fix: a base class replaced by a module-level alias (
PreTrainedTokenizer = PythonBackendin transformers 5) no longer makes every inherited member look removed, and when a class's bases cannot be followed at all its inherited members are no longer reported as removed. A member removed from a base class is reported once, on that class, with the subclasses that inherited it counted as similar. transformers 4.52.4 -> 5.17.0 goes from 42,270 reported changes to 6,515. - Fix: a removed class is reported as moved only when the class of the same name found
elsewhere keeps at least half of its public members. Otherwise it is reported as removed, and
the unrelated class is named (
openai.Completionin 0.x is notopenai.types.Completion). - Fix: in namespace distributions (
google.genai,azure.identity, ...) objects were looked up below the wrong module, so parameter, signature and deprecation changes were missed and some removals were false. google-genai 1.3.0 -> 2.25.0 loses five false__init__removals and gains a parameter that is now required (errors.APIError(response_json=...)). - Kind changes say what changed ("changed from class to function").
- Test suites, benchmarks and examples shipped inside a package are no longer diffed
(
pkg.testingorpkg.testdirectly under the package still is). Type-checker plugins, compatibility shims and per-backend modules (pydantic.mypy,sqlalchemy.dialects,polars.interchange, ...) rank lower. - Deprecations declared with a library's own decorator (any decorator whose name contains
"deprecat", such as polars'
@deprecate_renamed_parameter) are reported. A renamed parameter that is still accepted is reported as deprecated rather than removed.rundoes not probe these, because the type checker cannot see them. - Faster cold scans: package sources are downloaded in parallel, and similar-name suggestions are skipped for a package with more than 2,000 removals.
- Warnings that Python prints while parsing old package sources ("invalid escape sequence") are silenced. Diffs cached by 0.1.0 are recomputed.
Ranking and reports
- A changed method or attribute now counts as "used by your code" only when the code also names
its class (so
createno longer matches every class with acreatemethod), and repeated changes are listed under their shortest public path. This affectsproject_changestoo. - A changed parameter counts as used only when the code also names its function:
hf_hub_download(..., resume_download=True)no longer markssnapshot_download(resume_download=...). Changes where the code names both the function and the parameter come first, then those where it names only the function. The marks say what the code uses (your code uses hf_hub_download and resume_download) and appear only for packages the code imports; a namespace distribution such as google-cloud-storage no longer counts as imported because the code importsgoogle.genai. - Every report counts the same way: a change reachable under several import paths is counted
once. The terminal summary,
report.md,results.json(breaking_changes,deprecations), the Markdown summary, the GitHub Action's outputs and the MCP tools now give the same numbers, and the full report lists each change once with an example of its other paths (results.jsonstill has every path). since-cutoff scan --cutoff DATEwithout--modellabels the report as a custom cutoff instead of guessing a Claude model, and looks up no model (modelandmodel_specare null inresults.json).- Fix: the summary panel no longer crops long lines in CI logs and pipes; it wraps them. The change counts are on a line of their own, and the panel is wide enough for its subtitle.
- Fix: when several models.dev providers list the same model id, the model maker's own entry
now wins (for example
openaiforgpt-5.4, not a reseller that sorts first).
0.1.0 - 2026-09-26
First release.
since-cutoff scan: find the dependency versions a model could have seen at its training cutoff and statically diff their public API against the versions your project uses.since-cutoff run: probe the model on the most relevant breaking changes, score its code with basedpyright against both versions (stale / wrong / deprecated / correct), write verified AGENTS.md notes and measure their effect on held-out tasks.- Lockfiles: uv.lock, poetry.lock, pdm.lock, pylock.toml, Pipfile.lock; requirements files;
.venvmetadata; pyproject.toml. - Providers: Claude Code CLI, Anthropic API, OpenAI, OpenRouter, DeepSeek, Ollama and any OpenAI-compatible endpoint.
- Claude Code plugin with a
since-cutoffskill. --effort(defaultlow) for Claude Code calls, and only API-knowledge errors (unknown names, imports and parameters, missing arguments, arity) count as stale or wrong; type-strictness complaints do not.- A reproducible example project in
examples/agent-appand a first real run in the README.