/pro: a page for Trazum Pro, which says it is in development and not open yet. Linked from the header and
the footer, in the five languages the site speaks. In order: what Pro answers for an organisation (where the model
spend went, whether it is inside its budget, what changed when it moved, a figure an auditor can trace); the one
property it is built around, that no prompt text reaches its server and what travels is a receipt, made by
trazum receipt in this repository and held by receipt-redaction.test.js, with the label named as the one field
that travels as it was written; what stays free in the open tool and what Pro adds, in the words of
docs/licensing.md; the tiers, by managed spend a month and not by seat (Team €149 up to €5,000, Growth €499 up to
€25,000, Scale €1,499 up to €100,000, Enterprise by agreement) with the sentence that makes the share the
break-even; and the status, with one call to action. That is a mailto: link to the address CODE_OF_CONDUCT.md
publishes, the subject filled in, and a link to the repository's releases: no form, no field, no cookie, no request
and no dependency. The tiers and the status are one module, apps/web/lib/pro.ts, whose comment names Trazum Pro's
own docs/pricing.md as where the owner decided them; the page formats them and types no figure. The site gains a
sitemap.xml of its pages, which it did not have, named by robots.txt, and the layout's site address moves to
lib/site-origin.ts so the two read one. pro-page.test.mjs holds the page: the tiers parsed back out of the
rendered table in every language and compared with the module, and the module with the owner's figures written
again in the test; each share equal to its price over its ceiling; the not-open sentence and the status while
PRO_OPEN is false; no claim an open service would make; the one mailto equal to the one address the repository
publishes; the page in the header, the footer and the sitemap; every pair of text and ground it uses at 4.5:1 or
better in both themes, worked out from globals.css; and nothing sent. A twenty-third browser flow follows the
header's Pro entry from the landing, reads the four tiers written by hand, finds the one mailto, measures every
text's contrast on paper and then with Dark chosen, and fails on any request that leaves the origin; the documents
that count the flows say twenty-three. Six faults were planted and each failed a test: Growth printed at a price the
module does not hold, the not-open sentence removed, the status above the title removed, Pro taken out of the
header, a fetch to another host on load, and an image requested from another host with its address built from
parts, which the browser flow caught by the request it saw. (#793)
Codacy and DeepSource read the repository from a configuration that is in it, and Codacy is sent the coverage.
The owner installed both on 2026-11-18. .codacy.yaml and .deepsource.toml leave out the two directories a
script writes (wiki/, plugin/skills/), so a finding is reported once and against the file a person edits, and
.deepsource.toml says what the code is: TypeScript, ES modules, for Node, with React. Without it DeepSource's first
review of a pull request reported the CLI's own printing as "console in code that runs on the browser" and every
function at the top of a module as a declaration in global scope. The Coverage workflow's last step sends
Codacy the reports it already writes: Codacy's reporter at a pinned version, 14.1.3, refused unless its SHA-512 is
the one its publisher lists, never its install script and never an action; the token from the repository secret
CODACY_PROJECT_TOKEN, read from the environment and never on a command line; nothing fetched where there is no
token, as on a fork's pull request. Codecov stays where the record is kept, and the step cannot fail the job because
of Codacy: no token, a failed download and a refusal each leave a line in the log. A reporter whose checksum is not
the pinned one does fail it, and is not run. Neither service is a required check, and a test holds the ruleset to
that. CONTRIBUTING.md, "The machines", names both and holds them to the rule already there for a review bot: a
finding is traced in the code first, and a wrong one is not quieted by changing code that was right. The first
reading of Codacy's 794 findings, group by group, is in the issue; none read so far is a defect in shipped code.
(#767)
One command turns on everything that speaks without being asked, and one turns it off: trazum proactive. Trazum can
speak first in three places, each off until somebody wired it by hand: what the session has cost, in Claude Code's status
line, with a Stop hook that refreshes it; trazum watch, which says when measured spend crossed a budget, from a
cron entry; and spend_guard over MCP, from the server entry in each client. trazum proactive reports which are on
(one line each: on, off, not ready with the reason, not available, could not tell), trazum proactive on
offers each one that is off and says every file and every line first, and trazum proactive off removes exactly the
lines it added. Nothing is written without a yes for that item: --dry-run writes nothing, and input that is not a
terminal without --yes is a dry run and says so. It edits ~/.claude/settings.json, the user's crontab, and
.mcp.json or .cursor/mcp.json in the directory it runs in (the two clients whose files the documents state), and
its own ~/.trazum/. Every write goes through one function that refuses a path off that list, a symbolic link and a
file that changed since it was read, writes a temporary file and renames it, keeps the mode, and keeps one backup
beside the file the first time it changes. A file is opened once, without following a link, and its kind and its
text both come from that open. An item is written whole or not at all: if one of its writes fails, what it had
already written is put back and nothing is recorded. A crontab that cannot be read again just before the write is
not taken for an empty one. The status line script is this command's only while it is the copy it wrote (the record
keeps its sha256): one you changed, or a file already there, is not written over and not removed. JSON is edited as data, keeping key order and indentation; a file that
does not parse, or whose hooks is not an object, is left alone and named; a status line somebody else configured is
never replaced; the hook is appended to Stop and never replaces what is there, and is never wired to
SessionStart, whose output is handed to the model. Its own lines are recognised by the exact command written (the
hook and status line), a trailing # trazum watch (managed) (the cron line) and a manifest of what it added (the MCP
entry, so one pasted from the README is not removed). The status line script is copied from the CLI package into
~/.trazum/statusline/, because plugin/ is not in an npx install, and a CLI run from the npx cache is refused
for the status line and the schedule: it would not be there tomorrow. A CLI file that is not executable is refused
for the status line as well, because the hook starts it by its path and fails without a word, and so is a home
directory with a quote in its name, which would end the quoting of the script's path. watch is scheduled only when the store has
something in it and trazum.config.json has a spend limit; otherwise it is not ready, naming the command or the
key, and the store is never filled nor a budget written. Sends nothing anywhere. A command of its own rather than a
mode of init, because init proposes a config for one repository and its --dry-run and --yes mean that; this
edits a home directory. The CLI now has 56 commands, and --json is documented in docs/json-output.md. (#755)
The documentation is on the site, at /docs. The header's Docs entry,
the footer's and the application rail's lead there instead of to
docs/README.md on GitHub, and the landing's links to the CI and agent
documents lead to their pages. /docs is the index, grouped as
docs/README.md groups it and opening with that file's own table of
tasks; /docs/<slug> is one page per document, with a contents list built
from its headings (sticky on wide screens, a disclosure on narrow ones),
the document's own anchors as GitHub gives them so old links keep landing,
View on GitHub for the same file, and previous and next within its group.
Thirty-six documents are published: the README as an overview, the
guides, references and trust documents under docs/, CONTRIBUTING.md
and VERSIONING.md. Plans, the audit, the compliance records, the CLA and
the policy and history files are not, and the index says they exist and
links each on GitHub. The list is one file, apps/web/lib/docs/manifest.ts,
and docs.test.mjs fails on a document docs/README.md links that has no
page and is not left out, on a file under docs/ in neither list, and on a
group docs/README.md does not agree with. Search over titles and headings
runs in the page from a small index the build writes: no server, nothing
sent, nothing typed put in the address. A relative link between published
documents becomes a link between their pages, any other relative link an
absolute GitHub link, and an anchor that does not exist stops the build;
images are copied and served from the site's own origin, and an image on
another host (the README's badges) is never loaded: the page shows its
description as a link. The Markdown is read by a reader written for the
subset the documents use, about twelve hundred lines with no dependency,
which builds a tree React draws, so nothing in a document can become markup;
it stops the build, naming the line, at a construct it does not know,
raw HTML included, and was checked against markdown-it on all 37 files
(same headings, lists, tables, code blocks, links and text). The
documents stay English in every language and each page says so. Two
documents had a paragraph run straight into ---, which GitHub and this
reader both take as a heading of the whole paragraph; each gained the
blank line it was missing, in README.md and docs/commands.md. The
Dockerfile now carries the documents into its build stage and the app's
public/ folder into the runtime image, which it had not. A fifteenth
end-to-end flow goes from / through Docs, a search, a result, and the
heading. (#735)
Mutation testing reaches the code that chooses a rate and multiplies by
it. A target in scripts/mutate.mjs can now be part of a file,
{ file, functions }, found by name among the built file's top-level
declarations; a name the file does not declare, or a listed function with
nothing to change, stops the run. pricing.ts is mutated in the ten
functions that choose a rate and give the cache and batch ratios, 212
mutants and none of the catalogue's numbers, and usage.ts in add, 79.
Their first runs caught 178 of 212 and 62 of 79. Two new test files,
rate-choice.test.js and bill-lines.test.js, each from a rule the code's
own comments state, killed 12 and 16 of the survivors: a Sunday billed at
DeepSeek's weekday peak, a promotion ended a millisecond early, a period of
the price history without ratios of its own priced at the defaults, the
undecided band billed at a cheaper band than the dearest, and the batch,
band, cut-off and unpriced-search lines of a bill, none of which a test
read. The other 23 are recorded with their reasons, so the record holds
62 survivors and 739 of 801 mutants caught, 92.3%, 5.1% of the core's
15,800. docs/mutation-testing.md also counts the catalogue's own
question: 681 published prices, of which a sample of 69 was measured and
50 are held by a test. --list counts each target's mutants and runs
nothing. Eight faults planted against the selection, eight caught. No
price, rate or date changed (#745).
A brand page: the wordmark, the colours, the type and how to use them.
/brand, linked from the footer, offers the wordmark and the plain T, each
for a light ground and a dark one, as SVG and as PNG: eight files in
apps/web/public/brand, written by scripts/draw-icon.mjs and held byte for
byte by brand.test.js like the icons. The wordmark is outlines of Space
Grotesk at weight 700, placed with the font's own advances, pair kerning and
the header's tracking, read from the font the app ships by
scripts/wordmark.mjs (the WOFF2 container, gvar, HVAR and the kern
feature, with no dependency); against a browser's rendering of the same text
it has the same bounding box, and 314 of 878,005 inked pixels differ, the
soft edges. The PNGs are filled from the same path by a scanline rasteriser
in scripts/brand-files.mjs. Every value on the page is read when the site
is built: the colours from globals.css by the role each row of
DESIGN.md's token table names, the typeface from where the stylesheet
declares it, and the voice, in three sentences, and the list of what not to
do from DESIGN.md, which gained a ## Using the brand section to hold
them. Each token has a copy button that writes the clipboard and sends
nothing. The page states no trademark policy: it points at the licensing
page, which says there is none. The social card each page draws now sets the
name as that wordmark, docs/assets/social-preview.html carries the same
outlines between two markers the icon script rewrites, and brand.test.js
holds both to the palette. A seventeenth end-to-end flow follows Brand from
the footer, fetches every file it offers and copies a colour. (#737)
Models and prices, the roadmap and the changelog are pages of the site.
/models is the catalogue the product bills with: every row of
@trazum/core's MODELS (91 at this commit) by provider, its rates in
formatUsd, cache and batch as the multiple the catalogue states, and in
the row's details its bands, service tiers, earlier periods, promotion and
note. Nothing is computed. A retired model, a promotion and a model with no
price are each drawn in form as well as words, the seven ids providers list
and the catalogue leaves unpriced are listed with their reasons and no
figure, and each provider shows the date it was last read and the page the
catalogue's source names. A provider and a text filter run in the page and
send nothing. /roadmap is .github/milestones.json in order, with issues,
the live milestone's address and no date, and ROADMAP.md's ## Under consideration. /changelog lists all 147 releases newest first, one anchor
each, draws the unreleased changes and the newest three, and gives every
release /changelog/<version>; a title in place of a date is shown as a
title. Of the file's 1,047,825 bytes the index module is 109,256, and the
page sent 326,008 bytes, 74,382 compressed. They are built at build time
by scripts/build-site-pages.mjs, with no request to GitHub, and
site-pages.test.mjs holds each to its source. The Markdown reader gained
~~strikethrough~~, and a sixteenth end-to-end flow follows Models.
(#736)
Mutation testing reaches the code that prices a call. billing.ts is
the sixth target: it says, for every call the bill and its findings price,
the moment it was billed at, the size of prompt that picks its band, how it
ran, and what its web searches cost. Its first run made 35 mutants and
caught 28, 80.0%. Two new tests in billed-at.test.js and one in
web-search.test.js killed 3 of the 7 survivors: a call with no clock could be
billed at 1970-01-01 instead of the report's date, a call's one-hour cache
writes could be left out of the prompt length that picks its band, and a
single web search could be billed at nothing. The other 4 change nothing a
caller can see and are recorded, so the file stands at 31 of 35, 88.6%,
and the whole record at 471 of 510, 92.4%, with 39 survivors on record
(#731).
Merging to main publishes the wiki. wiki/ was generated and checked,
and the last step was two commands the owner had to remember, so the
published wiki was only as current as the last time somebody did.
scripts/publish-wiki.mjs takes a checkout of the wiki's repository
(--into <dir>), copies the pages that differ and says which it wrote,
which were unchanged and which exist only on the wiki. A page only on the
wiki is reported and never deleted, the way a label only on GitHub is left
alone. --check prints the differences, exits 1 when a page of wiki/
differs or is missing there, and writes nothing. It refuses, with exit 2,
a wiki/ that scripts/build-wiki.mjs --check does not accept, a missing
--into, a directory that is not a git checkout and any other argument. It
commits nothing, pushes nothing, reads no environment variable and makes no
network call. The new Wiki workflow does the git: on a push to main that
changes wiki/, the script or the workflow, the publish job clones the
wiki with the job's own token, runs the script, commits as
github-actions[bot] with a message naming the commit of main it was built
from, and pushes, or says nothing changed and commits nothing. It is the only
job with contents: write, which GitHub's wiki needs because it has no
narrower permission; the token reaches git as an Authorization header in the
environment of a step, never in a URL or an argument, and its encoded form is
masked. Every Monday at 10:13 UTC, and on a manual run from any branch, a
read-only compare job runs --check, so a page edited in GitHub's editor,
or a merge that was never published, is noticed. There is no pull request
trigger. The wiki needs one page saved in the web UI before the first
publish, because a wiki with no page cannot be cloned; the two commands
build-wiki.mjs prints stay as the fallback. wiki/ has 9 pages, as
build-wiki.mjs --check counted. The push itself was not run from the
session that wrote it, which could not reach the wiki's repository, so the
workflow's first run on main is the first real one. What was measured here:
git sends a header given through GIT_CONFIG_* for one URL to a local server.
wiki-publish.test.js holds the script, the workflow's permissions and its
token handling, and the documents; SECURITY.md says what the workflow may
write and what limits it (#726)
The site opens on the landing, and the application moved to /app.
/ is the landing; the application is unchanged at /app and still opens
on the bill. /?tab=<name> redirects permanently (308) to /app with every
parameter it carried, /landing to /, and a bare / is never redirected:
redirectFor in apps/web/lib/site.ts decides, the middleware answers
before anything else, and the target is always this origin. Share links,
the badge, /admin and the API keep their addresses. Every public page has
one header and one footer, built from one list of entries: the full
wordmark home, Playground and Docs (the docs index on GitHub until the site
has its own), the language and appearance controls, a GitHub button drawn
inline with an accessible name, and the primary action into the dashboard;
below 1280px the entries move into a menu that is a disclosure and holds no
focus. The footer adds the licence, the changelog, the security policy and
the npm package. The landing is rebuilt from the README's own sentences:
its first line as the headline, npx @trazum/cli bill with a copy control,
the README's illustrative bill from examples/claude-projects (labelled as
the README labels it, and held to what the CLI prints), why the number holds
up, what never leaves the machine, the CI gate, the agents' budget check
and prompt trimming, and the command again. The application's rail and
phone bar gain the way back to the site and the same GitHub button, and the
bill panel opens on one control that loads the sample month. Each public
page has its own title, description, canonical address and social card,
drawn in the colours scripts/brand.mjs names (which gains the light
tokens, held to globals.css by brand.test.js), and an unknown address
gets a branded page with the way home. Every link to the web app in the
README, the docs, the skill and the wiki uses the new addresses, and
site-links.test.js fails on one that would only redirect. A fourteenth
end-to-end flow follows a visitor from the landing to a priced sample
month (#734).
Discussions has a form for each category a visitor writes in, and one
address. GitHub Discussions was switched on on 2026-11-18, and the only
thing that sent anybody there was a line in config.yml. .github/DISCUSSION_TEMPLATE/
now holds q-a.yml, ideas.yml and show-and-tell.yml. Each opens by asking
for no usage log, no prompt that is not public and no key, then asks what an
answer needs: for a question, the goal, the command, what happened and what
was expected, the version and how Trazum was installed; for an idea, the
problem first, what is done today, and a pointer to the feature request form
for an idea that is clearly a thing to do; for show and tell, what was built
or measured and how to repeat it. There is no form for announcements, which
only the maintainer posts, nor for polls. The file names are GitHub's default
category slugs, which could not be read from the repository, and each form
says so at its top; a category that was renamed loses its form until the file
is. Whether GitHub accepts the forms was not tested. README.md now says a
question goes to Discussions and a bug to an issue, through its form.
issue-intake.test.js holds the forms (a first block that says what not to
paste, unique field ids, the version where a run is described, the slugs) and
requires every page that sends somebody to Discussions to use
https://github.com/Davmunrey/Trazum/discussions and nothing else. The
Repository settings check now also compares has_discussions with true,
reports it as not read when GitHub does not show it, and writes it with
apply --yes; switched off, three pages would point nowhere. Whether the
workflow's token is shown that field was not measured. (#732)
Vercel Speed Insights, off unless the operator switches it on. Vercel's
bot opened #722 with @vercel/speed-insights rendered in the layout
after <Analytics />, always on. That contradicted what the README,
SECURITY.md and the wiki promise: analytics is off by default, nothing
records page views on its own, and every URL that leaves has its share
token replaced and its query dropped. #722 was the bot's version, and this
one differs in four ways. The switch is the build-time variable
NEXT_PUBLIC_VERCEL_SPEED_INSIGHTS, on only for the exact value 1, read
in lib/analytics.ts beside the PostHog key. The package is imported
dynamically inside the on branch of SpeedInsights.tsx, the way
posthog-js is, and a test fails if any file under apps/web imports it
statically. Every measurement passes beforeSend through
redactUrl, the rule PostHog events use, and one whose URL does not parse
is dropped. And the lockfile gains the package and nothing else: npm
10.9.9 on this machine also removed sixteen libc fields, as the bot's
lockfile did, so the entry was restored by hand and npm ci accepts it.
Read from the package, not from Vercel: the script that sends the
measurements is served at /_vercel/speed-insights/script.js and is not in
the package, so what it sends was not read, and it only works on a Vercel
deployment. The Content-Security-Policy does not change and does not read
the variable: the script is on the page's own origin and is added by a
script the nonce vouches for. In a production build served with the
variable set to 1, Chromium requested the script, got the server's 404
because this machine is not Vercel, and reported no policy violation. A
test builds the policy in two processes, one with the variable and one
without, and requires the same bytes. With the variable unset the package
is in one 3,471 byte chunk that the page never requests; the same was true
of posthog-js before this, because Next here does not fold the
environment variable away at build time. The README, SECURITY.md,
.env.example, docs/setup.md, the rotation page and the wiki say all of
this (#723).
The roadmap's order is held in a file, and GitHub's milestones are made to
match it. .github/milestones.json is an ordered array, first is next:
each entry has a title, a description and the issues that belong to it, and
none has a date, because the order is the commitment and the calendar is not.
npm run milestones reads GitHub's milestones and open issues through gh
and prints each difference as a sentence, exiting 1 on one: a milestone the
file has and GitHub lacks, a different description, an issue in another
milestone or in none, an accepted or blocked issue the file places
nowhere, an issue in two milestones of the file, and a due date. A milestone
only on GitHub is printed and left alone. apply says what it would change;
apply --yes creates, corrects and places, never deletes, then reads GitHub
again and judges that reading. The Milestones workflow applies the file
when a change to it merges, from the one job that holds issues: write,
reports on a pull request, and fails every Monday when GitHub has drifted.
ROADMAP.md carries the ordered list, each title linking its live milestone,
drawn from the file by node scripts/milestones.mjs roadmap, and the wiki
gains a Roadmap page generated from its Next section (#720).
Codecov groups the coverage by package. codecov.yml now defines one
component for each package the coverage run measures, core, cli, mcp
and tokenizer-openai, each by the path of its sources:
packages/<name>/src/**, which is the shape every path in an uploaded
report has. A component is defined in the file alone, so nothing changes at
upload time. There are no component statuses and none in default_rules:
the plan does not include them and a status nobody can read is noise.
Codecov's validator accepted the file. Codecov's settings page lists
Components as available with its Pro plan, as read on 2026-11-18, so the
configuration is in place and the plan decides whether it is shown.
coverage.test.js holds the components to the packages the script
measures, and docs/coverage.md says what they are and where they show
(#717).
Test results and the web app's bundle size go to Codecov. Two things
Codecov offers were left unconfigured on purpose when coverage was set up,
and the owner asked for both. Test analytics: the coverage run now also
writes each package's results as coverage/<package>.junit.xml, which
Node's runner produces itself, and the Coverage workflow uploads them
with the uploader it already pins and checks. It answers what the required
job cannot: which test fails some of the time, as one in the core did on
two of five runs on 2026-11-18. Bundle analysis: a new Bundle workflow
builds the web app and scripts/bundle-report.mjs sends the size of
everything under apps/web/.next/static. Measured that day: 22 files,
1,851,354 bytes, 552,234 compressed. Codecov's Next.js plugin is for
webpack and the web app builds with Turbopack, so the standalone analyzer
is used and nothing is added to the web app's build; it is installed in CI
outside the workspace at one exact version with install scripts off, the
script refuses any other version, and its telemetry is switched off.
Neither is a required check, both statuses are informational, a report
Codecov does not take is a warning on a pull request and a failure only on
main, and the token is read from the environment by name. The build
names chunks by a hash of their contents, so the total is the figure to
read and the per-file difference is not. docs/coverage.md says what is
sent in each case: test names, durations and failure messages; file names
and sizes. No source (#714).
The ruleset GitHub enforces is compared with the one in the repository.
.github/rulesets/main-branch.json is the branch policy, and GitHub
enforces a copy an admin puts there. Nothing read the copy, and on
2026-11-18 it had drifted: it lacked PR readiness, which the file had
required for weeks, and allowed merge commits, which the file did not.
Every pull request that had changed the file was green. npm run ruleset
reads the live ruleset through gh and prints each difference, rule by
rule, naming the entry only one side has; it exits 1 when there is one. It
also reads the five merge settings the ruleset leans on, each with why, and
says "not read" for one the token is not shown, which is neither fine nor a
failure. npm run ruleset -- apply says what would change, and with
--yes, from an admin's own gh, writes the file to GitHub, sets the
settings and reads both back. The file is held exactly for what it states:
a parameter GitHub reports and the file is silent about is printed and left
alone, on reading and on writing. The Repository settings workflow runs
the comparison every Monday and fails on a difference; on a pull request
that touches the file it reports and does not fail, since such a pull
request differs from GitHub by design until an admin applies it. The
workflow reads and never writes, and no admin token is stored for it.
Its first run on a runner showed what a local run with an admin's token
could not: GitHub leaves bypass_actors and the four allow_* settings
out of its answer to the workflow's token. Comparing that absence with the
file's empty list would have failed every Monday for something nobody
changed, so those five are printed as "not read", and any other field that
goes missing is still a difference. SECURITY.md said "nothing syncs it";
it now says what does, and what the weekly run cannot see (#708).
Line coverage, measured and sent to Codecov. The repository said how
many tests it had and, on five files, whether they would notice a change;
nothing said which lines the tests run at all. npm run coverage runs the
four published packages' tests with Node's own coverage, mapped back through
the build's source maps so every path is a TypeScript file, and writes one
report for each package. Measured on 2026-11-18 with every suite together:
94.5% of 70,633 lines in 152 source files (core 95.9%, cli 94.0%, mcp
77.1%, tokenizer-openai 98.0%), figures rounded down. Two source files
are in no report: one holds only types, and the MCP server's entry point is
started and killed by its tests, and a killed process writes no count. The
Coverage workflow uploads the reports on every pull request and on
main. It is not a required check and is built so it cannot block a merge:
a test that fails under coverage does not fail it, an upload that fails
does only on main, and both of Codecov's statuses are informational, with
no target. The uploader is Codecov's command-line tool at a pinned version,
refused unless its checksum matches; the token is a repository secret that
reaches it through the environment. The workflow's first run was refused by
Codecov and went red: the secret had not reached the job, Codecov takes an
upload without a token only from a fork, and the uploader exits 1 on a
refusal whether or not it was asked to. A refusal on a pull request is a
warning now, as it was meant to be, and the log says whether a token was
set. The web app and the editor extension
are not measured yet, each for a stated reason. npm run done stopped the
change once before the push: a guard requires a rotation procedure for
every secret a workflow reads, and CODECOV_TOKEN had none. It has one
now, in docs/compliance/secret-rotation.md.
docs/coverage.md (#706).
One command that says whether a change is done, and why not. The pieces
of the loop were all here: npm run verify, the required checks,
PR readiness. What joined them was one session's habit, and on 2026-11-17
it missed twice: a new test file invisible to a test that reads the list of
tracked files until it was staged (#685), and a release reported finished
before its packages could be downloaded (#688). npm run done runs sixteen
criteria in order and answers each with passed, FAILED and the reason,
or not run and what is missing: every new file tracked, every commit
signed off, a changelog line under Unreleased, an issue named, then each
step of CI's required job as CI writes it (the command of a one-line step is
read out of ci.yml when it runs), then mutation testing when a changed
file brings it into play. It adds no criterion of its own, fixes nothing,
and exits 0 only when everything that applies passed; not run is not
passed, and part of the list is never a verdict. done.test.js fails
when a step is added to the required job that is neither a criterion nor
left out with its reason, when a criterion names a step, a heading or a
test that is not there, and when the script gains a command that writes.
docs/done.md states the loop, and a new AGENTS.md points
a coding agent at the command, the document and the review skill. Its first
whole run, on this change, answered "not done": three lint findings in its
own test. Thirty-eight faults were planted against done.test.js; all were
caught, one only after it was planted again, because it had removed one of
the two places AGENTS.md names the command and the file still named it
(#694).
A review skill that carries this repository's own rules. What a review
here looks for was written for a person in CONTRIBUTING.md and for a bot in
.coderabbit.yaml, and a coding agent in a checkout had neither as something
it could run. .claude/skills/trazum-review/SKILL.md is that: sixteen rules,
each with the paths that bring it into play, where it is stated, what holds
it and how to check it, and the form a finding is reported in. It restates
no rule. review-skill.test.js holds every pointer: a path that exists, a
heading that is in CONTRIBUTING.md, a test file that is in the tree, an
npm script that is a script. It fails when the Review section gains a
question the skill does not point at, when the bot is given a path no rule
applies to, and when the skill names a command that would change the
repository: it reviews and does nothing else. One rule the skill could only
point at a comment for now has a test: no test file bounds a section of a
document by looking for the heading after it (#693).
End-to-end tests of the web app. The web app had 51 test files and none
of them opened the page. The one thing that drove a browser, the privacy
probe, checks a single promise, and a page can keep it and print the wrong
total. scripts/e2e.mjs runs twelve flows in a real browser against the
production build, each from an empty browser: a pasted log priced to the
cent by part, label and model; a paste that is not a log refused with the
lines it could not read; the same bill at phone width with no sideways
scroll; a prompt optimised and two compared; the prompt writer's next
question; a playground command; a recorded run read into a report on the
Tasks tab; every tab by click and by address; dark mode and Spanish
surviving a reload; the phone's menu. A flow also fails on any error the
page throws. Every expected figure is worked out by hand in a comment
($1.43 for the bill, $1.575 for the run), and e2e.test.mjs holds the
three prices that arithmetic assumes, so a price change says to re-price
the log before a browser says it waited for a total. The same test fails
when a tab a visitor can open has no flow, when a flow claims a tab it
never names, when the step leaves CI or is made unable to fail, and when
the runner is asked for a flow that does not exist. The library tab is left
out by name: it needs an account. Twelve faults were planted in the app in
two builds and every one was caught, eleven by the flow written for it and
the last by every flow that had nothing else to fail on: a cache read at a
fifth of input ($1.47), a theme not remembered, a lang attribute not
following the switcher, a tab that no longer rewrites the address, a paste
box wider than a phone, a comparison without its percentage, a count the
wrong way round, one answer too many asked for, unreadable lines counted
and not named, a chosen file dropped, a menu button that opens nothing, and
an error thrown after mount. Eighteen more were planted against
e2e.test.mjs. Two escaped and each has a test now: a tab opened only by
the flow that walks the rail counted as covered, and a build step removed
outright passed a check that it came first. The flows are a step of the required
Build and tests check, with the browser driver the probe already
installs; they took 17 seconds locally. npm run e2e,
docs/end-to-end-tests.md (#692).
A linter, and the dead code it found. Nothing linted this repository:
strict TypeScript and CodeQL catch type errors and known security patterns,
and neither says a word about a name nobody reads. npm run lint runs
Biome 2.6.4 over every tracked file, 886 of them in under a second, and
fails on a warning as it does on an error. It is the first thing
npm run verify does and a step of CI before the build. With its
recommended rules and the style group off it reported 90 errors and 103
warnings on 2026-11-18. What was a mistake is fixed: 14 names nobody read
(a PUBLISHED_BAND constant the token-band test defined and never compared
anything with, among them), 7 imports of nothing used, 16 parameters nothing
read (six functions lose one, with every call site; the rest are dropped,
or marked unused where a caller still passes them), three
Object.prototype.hasOwnProperty.call that are Object.hasOwn, and seven
test patterns written [^] that say [\s\S] now. What the code does on
purpose everywhere is a rule switched off in biome.jsonc, 16 of them,
each with its reason on the lines above. What it does on purpose in one
place carries a biome-ignore and its reason next to the line: seven, in
the web app and the editor extension's declarations.
Three React rules are off without an answer: 28 findings about effect
dependencies, index keys and components defined inside components, which
wait for the end-to-end tests of #692 and are tracked in #696. It lints
and does not format. lint.test.js holds the configuration: the pinned
version, a warning failing, the count of rules that are off, a reason above
each, and a reason of some length on every excused line. A development
dependency of the repository only; no published package gains one. (#691)
Mutation testing for the core, and the 79 tests it showed to be missing.
scripts/mutate.mjs changes the built code of five files one small thing at
a time (a < into a <=, a * into a /, a call taken out) and reports
every change no test noticed, at the line of TypeScript it came from. The
files are the ones where a wrong line costs most: optimize.ts,
segment.ts and rules.ts, which rewrite a prompt, and savings.ts and
session-cost.ts, which turn token counts into money. The first whole run,
on 2026-11-17, caught 277 of 446 mutants: 62.1%. A cache read could be
divided by its multiplier instead of multiplied in the cost of a
conversation; the median could take the wrong element of any list whose
middle values differ; the percentage a prompt was reduced by could be a
hundredth of itself; two protected spans that touch could lose one. All of
it passed 2,994 tests. Five new test files, each written from the survivors
of one target, bring the recorded figure to 408 of 446: 91.5%. The 38 left
are in mutation.baseline.json and read one by one in
docs/mutation-testing.md: 24 change nothing a caller can observe, and 14
are not settled. dist is never edited: a loader serves each mutant to one
process. Each mutant is given only the test files whose coverage reaches it.
Before any result is trusted the loader is checked both ways, every mutant
is parsed so a syntax error is never counted as a caught bug, and --audit
runs recorded survivors against the tests they were not given: the first
day's run chose tests wrongly for every a ?? b whose right side never ran,
and that is how it was found. The parser it needs is installed outside the
workspace, pinned, as the privacy probe's browser driver is: nothing
published and nothing in the lockfile depends on it. The Mutation testing
workflow asks a pull request about the lines it changes and runs every
target on Mondays. What is not mutated is said on the same page as the
score: regular expressions, the contents of strings, a for loop's counter,
and every file but those five, which are 446 of the core's roughly 15,700
possible mutants. (#690)
A schema with thousands of keys no longer holds optimize for half a minute. The advisory that notices prose
restating an output schema asked one pattern of every sentence for every key, and built the pattern again each
time: the square of the text. A prompt of 40,000 characters, half a schema of 1,778 keys and half prose, made
optimize take 6.8 seconds, and one of 80,000 characters took 37.8, measured on 2026-11-18; the HTTP API accepts 400,000. The prose is now
read once, every key looked for in one pass, and the key's own pattern only confirms the place: 80,000 characters
take 0.37 seconds. The answer is the same, in the same order: restated-format-scaling.test.js compares the two
on 3,000 generated cases, holds the case folding to the engine's own over every cased character, and fails when
four times the text takes ten times as long. Found by reading a Codacy finding that called the pattern a
regular-expression denial of service; the pattern was linear, the loop around it was not. (#772)
Every finding Codacy lists is answered, and a script says when one is not. #772 read the 204 findings outside
the tests one by one: 6 fixed, 92 from two tools and two patterns switched off, 106 dismissed with a reason a
reader can check, in .github/codacy.json. The 710 in the tests are left out by .codacy.yaml, and a test holds
that no shipped source is. npm run codacy reads Codacy's public list and prints what the file does not account
for, including a new finding of a kind already dismissed; apply --yes, with an account token, switches off what
the file says and dismisses the rest, a hundred at a time, without printing the token. Each regular expression a
finding named was timed at a text and one four times as long; two in the docs build's markdown reader grow faster
on hostile input and only ever read the repository's own documents. Also fixed while reading: the terminal
pictures' accessible name now escapes a quotation mark, the image runs as user 1000 by number, and the two plans'
repeated headings name their arc. docs/coverage.md, "Codacy",
says what is off and why. The nine findings Codacy raised on this change's own code, in the new script and the new
detector, were read and recorded the same way, and a tenth, the record quoting the CI database's throwaway login,
was reworded. (#772)
The landing's terminal stood in the top of its window; it is centred
now. Measured in a browser at five sizes, light and dark, through the
whole story: at 1440x900 the bill's output had 72 px above it and 525
below halfway through its scene, its middle 226 px above the window's,
and once the output filled the column the lines scrolled on up to the
window's edge. Two things put it there. The column printed from its top
and moved only to scroll, and it scrolled and was sized by a line height
worked out for 19 px type while the lines were set in the still page's
15 px. Now the line height is read from the column's own type, the
column is centred across the free part of the window (beside the scene's
plate on a wide screen, under it and above the marker on a tall one) and
down it, and lines scrolled past its top are clipped, so a long output
has the same room above as below: 72 and 72 at 1440x900, 16 and 16 at
390x844. On a tall screen the free part is under the showing scene's own
plate, so Story.tsx measures each plate's foot when the stage or a
plate changes size, never while scrolling. As one plate gives way to the
next the output moves to the next scene's middle while only the plate it
moves away from is up, so it is never under a plate; on a tall screen the
plates fade where they stand instead of sliding 24 px. Across the swap
from the gate to the trimming, whose plate is 97 px taller at 390x844,
the output's top moves at most 16.5 px between two frames 0.5% of the
story apart (24.5 px of scrolling); there and at 768x1024 it comes no
closer than 15.8 px to a plate. The plate on a phone keeps the page's 16 px gutter (it was
15.6), and the closing band's padding is the other bands' 80 px at
1024 px and up (it was 96). The type, the copy, the colours, the scenes and their timing are
as they were. A browser flow measures where the output stands after each
run of output at 1440x900 and 390x844 and fails beyond 3 px or on a plate
taller than its words, and holds the output clear of the plates through
each swap at 390x844 and 768x1024; ten faults were planted in the page
and three in the flow's own test, the alignment as deployed and plates
stretched to the tallest one's height among them, and each was caught.
(#770)
The pull-request guide no longer asks Dependabot to link an issue. A
bot cannot, so on a green dependency update (#655) the guide named
@dependabot[bot] and never reached the step that moves it: the
owner's approval, which GitHub accepts on a bot's pull request and
records as a review. pr-guide.yml now pins the version from
Davmunrey/Zolts#116: a bot's pull request is not asked for an issue,
a green one tells the owner to approve and merge, and the owner's review
is requested once, which notifies them. The pinned file was fetched
from the new commit and matches the new SHA-256. (#773)
The wiki's Home page closed a <div> it never opened. The page is a
section of the README, and the cut fell after the closing tag of a block
whose opening tag is above it. scripts/build-wiki.mjs now pairs the tags
of every page it writes: a closing </div> with nothing open is dropped,
one left open is closed, and a code fence is left alone. wiki.test.js
holds every page to closing what it opens, and checks that the README
section still hands Home the orphan, so it cannot pass because the input
stopped exercising it. (#765)
PR readiness told a pull request with twenty-two lines under
Unreleased to add one. scripts/pr-readiness.mjs read this file with
git show through execFileSync and Node's default limit on a child's
output, which is 1 MiB. This file passed it, the read failed, and the
script's fileAt turned every failure into an empty file, so it compared
nothing with nothing and blamed the author. It is a required check, so
every pull request after that one would have failed it. The limit is set
now, and fileAt has two answers, the file or "this commit does not have
it"; anything else ends the run with the code for "could not judge" and
says what could not be read. The tests run the script on a real repository
whose changelog is over 1 MiB. Four faults were planted and it failed on
each, among them the script exactly as it was (#754).
The linter was 1,071 bytes from failing every pull request. Biome warns
about any file over 1 MiB that it is given, a warning is an error here, and
this file was 1,047,505 bytes on main. The next entry longer than what
was left would have failed the required check for a pull request that had
done nothing wrong, and so would every one after it. It was found when a
change with an ordinary entry did exactly that. Biome read 102 Markdown
files and has no rule that reports on any of them: without them the same
run checks 857 files in place of 959 and finds the same things. So the
linter does not read Markdown any more, and biome.jsonc says why. The
limit itself is not raised, because a source file of a mebibyte is worth
the warning. lint.test.js now fails by name on the next file the linter
reads that reaches the limit, and on a changed limit. Three faults were
planted and it failed on each: Markdown read again, the limit raised, and
a source file of 1.1 MiB added (#751).
The versioning policy described a line that ended in August.
VERSIONING.md still had "The 1.x freeze", "a breaking change waits for
2.0" and ^1.50.0 as the pin to copy, with the manifests at 2.7.12, and
this file opened with the rule for versions below 1.0 and no other. It now
says what holds inside 2.x, that a breaking change waits for the next major,
and what 2.0.0 was: a major that broke nothing, as ROADMAP.md records. One
promise had come due unnoticed. The 1.8.0 entry that deprecated tier on a
model said it would be removed in 2.0, and 2.0.0 removed nothing. The policy
now lists it under what is deprecated and still working, says the removal
did not happen, and leaves whether it goes in 3.0 undecided, because nobody
has decided it. The field's own comment said "removed in 2.0" and says the
same now. Nothing is removed and no behaviour changes. The release steps
said the type-check covers four workspaces and it covers six.
versioning.test.js holds the policy to the major in the manifest, the pins
to that major, the list of deprecations to every @deprecated in the
packages' sources, and the two workspace counts to the workspaces. It found
a second ~1.50.0 in the first run. Sixteen faults were planted, among them
the manifest moved to 3.0.0 with the policy untouched, and it failed on each
(#747).
Nine places where two documents disagreed now agree, and two were not
contradictions. An issue listed eleven candidates; each was read on both
sides against the code and this file. Real: (1) ROADMAP.md offered the
editor extension as open and scheduled while saying it shipped in 1.86.0.
Both are true of different facts, and each place now says which: it is built
and packages to a .vsix, and it is not on the Marketplace, which is #640.
(2) The Under consideration opening said nothing there was built, above an
entry struck through as shipped; it now says the struck entries are the
record of what the file went back on. (3) docs/mutation-testing.md said 38
survivors for the audit and 35 everywhere else: the audit ran over the 38
that were on record that day, and the page now says so and gives the 35 the
record holds now. (4) and (5) The plan index called the 1.83 to 2.0 plan
written and nothing delivered, and the 2.4 plan in progress; 2.0.0 and 2.4.0
are in this file, and the rows say what each delivered and, for 2.4, what
waits on something outside. (6) docs/commands.md called LangSmith, Helicone
and LiteLLM unbuilt above the three sections that document them, and
ROADMAP.md called from-langsmith unreleased; it is in 1.83.0. The plan
itself stays as written and the index row says what became of it. (8) The
1.52 to 1.60 plan says Mistral is unfronted; the 1.82.0 entry in this file
has the gateway fronting it, and the index row says so, leaving xAI and
Moonshot.
(10) The roadmap's forecast that the tokenizer question lands in 1.54.0 now
carries what happened: 1.85.0 answered it with a separate package, #642 asks
about DeepSeek and Mistral ones, and 1.54.0 stays open for Google, xAI and
Moonshot. (11) The roadmap's last section stated the rule for versions
below 1.0; it now gives the three meanings VERSIONING.md states and calls
the below-1.0 rule history. Not contradictions: (7) the README says xAI
retired grok-4 on 2026-05-15, which is xAI's notice, and the catalogue
has no retired mark on it, which records a refusal nobody here has seen;
and (9) docs/our-own-medicine.md says Moonshot and xAI were not probed for
availability while the roadmap says Google's estimator error is unmeasured,
which are two questions. Both pairs are left as written.
Three guards keep them from coming back. docs.test.js reads the plan
index and fails a row that says a plan is unfinished when the release the
plan ends at has a heading here. mutation.test.js holds every count of
survivors on record in docs/mutation-testing.md to mutation.baseline.json.
roadmap-forecast.test.js read ROADMAP.md only, and now reads every page
that says what exists, plans and records excluded, for a shipped converter
called unbuilt. Planted, fourteen faults, all caught. (#727)
Segmenting a text of many protected spans no longer takes the square of
them. For every match, the segmenter asked whether it overlapped a range
already reserved by looking at every reserved range, and asked whether a
quotation held a reservation by looking at every quotation. A text of
little but placeholders, tags and code spans has as many reservations as
matches. Measured on 2026-11-18: optimize took 0.5 s on 70,000
characters, 3.3 s on 140,000, 16 s on 280,000 and 26 to 30 s on 399,000,
which is under the 400,000 the HTTP API accepts. Both questions are now
answered by halving over ranges that are in order and do not overlap, and
the same 399,000 characters take 1.1 to 1.5 s; the segmenter's share went
from 10 s to under 50 ms. What found it was a test with a five-second
budget failing one coverage run in three on a runner, which was read as a
flaky test until the run could name it (#712). The suite's own comment had
excused this very fixture as "doing exactly the work it is supposed to
do". The new tests hold it without a budget in seconds: the two searches
are compared answer for answer with the loops they replace, the number of
ranges a search reads is counted, and the segmenter is timed against
itself at a quarter of the cap and at the cap. The file is under mutation
testing, and the record was made again: 92.6% of 475 mutants caught, where
it was 91.5% of 446, with none of the 29 the searches added left alive
(#716).
A test that fails under coverage is named. npm run coverage said "a
test failed in this run" and nothing else: the report was the run's only
output, so which test, where and why were in no log and no file. On
2026-11-18 two of the five Coverage runs that completed on a runner said
it of the core, on commits the required job had passed, and there was no
way to learn which test it was. The runner now writes its own account of
each run beside the report, as coverage/<package>.tap, and the output
lists every failing test with its file and line and the first line of its
error. A group that failed only because a test inside it did is not listed
twice, and a test marked todo or skipped is not listed at all. The job
still does not fail on it: the verdict stays the required job's (#712).
The coverage document no longer says its figure is Codecov's. The
script's comment and docs/coverage.md said the combined figure "is the
figure Codecov shows". That was written before Codecov had taken an upload.
The first, for main on 2026-11-18, came out at 93.3% (65,907 lines run,
111 partly, 4,615 not) where the same run's npm run coverage printed
94.5% (66,809 run), over the same 70,633 lines in the same 152 files. The
document now gives both and what is known: the script counts a line by its
line record; Codecov's ratio is hits over hits, partials and misses, and it
judges a line that carries a branch record by the branch, so a line that ran
108 times with an if nobody takes is, to Codecov, not run. Of 1,044 lines
the two disagree on, 1,023 carry a branch record. It also says what is not
known: Codecov called 353 lines run although every report says a branch on
the line was never taken, and why was not tested. The README has a coverage
badge, showing Codecov's figure (#709).
A quick edit to a description no longer leaves a cancelled required
check. PR readiness runs when a pull request is opened and again when
its description is edited, and the second run cancelled the first. Edited
seconds after opening, #699 was left with a cancelled PR readiness check
and a guide comment that said to fix a failing check while nothing was
failing. It was intermittent: the same edit on #700, #701 and #702 did not
show it. A run in progress now finishes, as the triage workflow's has since
#689; the runs for one pull request stay in order, so the newest
description still has the last word (#703).
The whole mutation run can start on a runner, and says why when it
cannot. Dispatched on main after #695, the Mutation testing workflow
stopped in 46 seconds: four of the core's test files failed before a single
mutant. The workflow built only the core and checked out one commit;
own-gate.test.js and security.test.js need the CLI built, and
changelog-coverage.test.js needs the tags. It builds everything and
fetches the history now, as CI's test job does. The fourth,
courtesy.test.js, needs neither: it asserted that hostile input is handled
within 1,500 ms, and its slowest case takes 795 ms on an idle machine. That
budget was a benchmark where the same tests elsewhere use a cliff detector,
and it failed in CI's ordinary test job too, on this very change:
guillemet: 1697ms on 180000 characters. It is 5,000 ms now, as in
security.test.js; the fault it guards against took 47 seconds. And since
any budget can be missed under enough load, a failure from a test file
that reads a clock is believed by the mutation run only when it fails
again with nothing else running, before any mutant and against one, and
those files are tried last. The tool printed which files failed and not
why; it prints each failing test and its error. And #695 merged green with
a workflow that could not run because a pull request that changes no target
returns before running a test: one that changes the tool, its record or
the workflow now runs one small target whole. Dispatched on this change,
the whole run passed on a runner in 1,259 seconds and caught the same 408
of 446 mutants the record holds, file by file. (#698)
A release waits until its packages can be downloaded, not until npm knows
their names. scripts/npm-serves.mjs waited for npm's latest dist-tag
to name the new version and stopped there. On 2.7.12, 2026-11-17, that check
passed at 22:42:49 UTC and @trazum/core's tarball answered 404 at 22:43:05
and 22:45:23, then 200 at 22:45:55: for about three minutes after the
release reported success, npx @trazum/cli@2.7.12 failed with E404,
because the CLI pins that exact version of the core. The check now asks for
each tarball as well, with a HEAD request to the address an install
fetches, and when it gives up it says which of the two it was still waiting
for. The Triage workflow no longer cancels a run in progress: on #687 a
description edited seconds after opening left a cancelled check that the
guide comment reported as a failure, and both runs can simply finish. And the
README's caption under the optimize picture says where its dollars come
from: the token counts and the $31.00 saved are the same anywhere, while the
first lever's $416.99 is what the command prints in this repository, whose
configuration assumes 300 output tokens a call. Outside it the published CLI
assumed 500 and printed $661.99 for the same prompt. (#688)