Skip to content
Trazum

2.0.0

Released 2026-08-30

Fixed#

  • The roadmap offered to build two things it had already shipped. ROADMAP.md ends with Under consideration, whose one job is to say "not scheduled, and here is the reasoning". Two of its five entries were shipped products: the editor extension went out as trazum-vscode in 1.86.0 and the per-model-family tokenizer as @trazum/tokenizer-openai in 1.85.0. The same file recorded both as released two hundred lines above, while the section below went on describing them as ideas — one of them with the words "still unscheduled".

    This was found while auditing the four conditions the arc plan sets for 2.0.0. The first is "every analysis this product can perform offline, it performs", and a roadmap that lists two of its own published packages as maybes cannot support that sentence.

    Both entries are gone, and roadmap-truth.test.js holds the property: no entry may be titled after a workspace that ships, and every entry left must say what blocks it. It is derived from package.json's workspaces rather than from a list of products, so a package added later arrives without being invited. The sibling repository has held this since its README existed — "the moment something is built it has to move out of the 'not built' table, and that move is the one people forget" — and this repository, the one strangers read, did not.

    Three plants fire: the editor extension put back as an idea, an entry naming no blocker, and a new workspace the guard has no phrase for. The parser caught its own first draft twice: it read the whole section including the paragraph explaining the removal, and it used $ under the m flag so every entry body stopped at the first newline.

  • The most load-bearing number in the product was stated three times and checked once. demo-image.test.js holds every dollar in the README's drawing to the pricing catalogue, which is thorough and was the right thing to build. The drawing is not where most people read those numbers: the README restates them in its alt text and again in the caption underneath, and adds one the drawing never states — 22 times more — which is the two of them divided.

    The sentence immediately after it is "that gap is the entire argument for this tool", and docs/pricing.md in the paid repository leans on the same ratio for its break-even case. So: three copies and a derived ratio, with a guard on one copy. An Opus 5 re-price would have moved the drawing, left the prose behind, and the README would have argued for the tool with two figures that no longer divide into the multiple printed between them.

    The README's figures are now read out of the drawing rather than written down in the guard — a second copy of them in the test would be the same fault one level up. Four plants fire: a figure changed in the drawing alone, the ratio left behind by its own two figures, stale token counts in the alt text, and a caption that drops one of the two figures entirely.

  • The guard that makes every other guard checkable walked a hand-written list of eleven directories, and missed 289 of 822 files. security.test.js refuses a raw NUL byte in a source file, because a NUL makes git call the file binary and a binary file has no diff — a pull request renders "this file cannot be displayed" and grep answers "binary file matches" instead of the line. Its own comment records the defect coming back once already, "one directory outside its reach", and the fix that time was to widen the list.

    Widening a hand-written list is what invites the third occurrence. Outside those eleven entries sat @trazum/mcp and @trazum/tokenizer-openai — two published packages — plus the editor extension and the Claude Code plugin, every one a shipped artefact. None held a NUL byte; nothing would have said so if they had.

    The roots are gone: the walk starts at the repository and the exclusions are the whole policy, each with a reason given. fixtures stays excluded because a fixture may hold a NUL deliberately. A second check pins the walk to eight named files across every package, because a skip added for one good reason can drop a package as a side effect — which is how the list came to be missing four of them.

    Three plants fire: a NUL in packages/mcp/src, a NUL in the editor extension — neither of which the old walk could see — and an exclusion that quietly drops a package. The floor rose from 100 files to 400.

  • Ten config key lists were second copies of interfaces, with nothing holding them together. CONFIG_KEYS, CONFIG_SPEND_KEYS and eight more are what rejectUnknownKeys compares an incoming trazum.config.json against, and each mirrors an interface declared a few lines above it. A plant added telemetry?: boolean to TrazumConfig, left CONFIG_KEYS alone, and all 2,115 core tests passed.

    Both directions of drift are user-visible and they fail differently. A setting on the type and not on the list is one the parser refuses by name — a documented setting that errors. A key on the list the type does not have is one the parser accepts and nothing reads: a setting you can write, spell correctly, and have silently ignored. For a budget that is a green build for a prompt nobody measured, which is the failure docs/commands.md argues the strict parser exists to prevent.

    All ten are now built from a Record<keyof T, true> over their interface, so both directions are compile errors. The published arrays and their order are unchanged. store has no named interface and is reached through NonNullable<TrazumConfig['store']> rather than by naming a type, which would have put a third copy in the file. Three plants fire: the setting that slipped through before (TS2741), a maxWeekUsd entry SpendConfig does not have (TS2353), and a key dropped from a nested list (TS2741).

  • The receipt whitelist said its guard caught a field added to the type, and the guard could not see the type at all. RECEIPT_LINE_FIELDS is the published list of what leaves a machine — exported, and read by anyone checking what a receipt can carry. Its comment said "the redaction guard reads this array rather than a copy of it, so a field added to ReceiptLine and not added here fails the guard."

    It does not. receipt-redaction.test.js collects the keys the emitter actually emits and checks each against the list, which catches an emitter emitting an unlisted field and is a real property. It cannot reach a field that is on the type and on no emitted line. A plant added operator?: string to ReceiptLine, emitted it on nothing the fixture built, and all twelve checks passed — and a field populated in one branch is exactly the shape a leak takes.

    The list is now derived from a map bound with Record<keyof ReceiptLine, true>, so both directions are compile errors: a field on the type and not on the list, and an entry on the list the type does not have. The exported array and its order are unchanged, because it is published. Three plants fire — the field that slipped through before (TS2741), a stale entry named sessionId (TS2353), and an emitted stray, which confirms the runtime half still holds what it always held.

    docs/commands.md said the whitelist "catches the field that carried it", which was true of the emitted case and is what that paragraph is about; it now also says why the other case needs the compiler.

Fixed#

  • Nine documents told readers the optimiser would break their email addresses and their indented code. Both are protected. Every document that enumerates the protected list had been written when it held five kinds, and each stayed correct right up until the night the sixth and seventh were added — which is the only way a document goes wrong quietly. The README told a reader an address was fair game while the code protected it; docs/authoring-rules.md told a rule author the same, in the paragraph it asks them to remember if they remember nothing else.

    Corrected in README.md (three sites: the opening claim, the protection paragraph and the src/segment.ts line in the layout), ROADMAP.md, CONTRIBUTING.md, docs/authoring-rules.md (two sites), docs/commands.md, docs/hardening.md, packages/core/README.md and both copies of the Trazum skill.

    docs/hardening.md is corrected to a narrower claim than the rest, on purpose. Its row states what the fuzzed corpus asserts survives byte for byte, and that is five of the seven kinds — fenced and indented code, inline code, URLs and addresses. Widening it to the protected list would have made the page claim coverage the suite does not have, which is the fault this repository exists to argue against.

    The guard binds prose to the type, not to a second copy of the list. protected-prose.test.js parses the ProtectionKind union out of types.ts and requires every member to be named, in prose, in each of the six documents that enumerate the list. A protection added to the union with no phrase fails before a document is read. This is deliberate: a checklist written from the same list it checks agrees with itself by construction, which is how the address hole survived a corpus built to catch exactly it, and how four other faults survived the same week.

    Three plants fire — a document losing indented code blocks, a document losing email addresses, and an eighth kind added to the union with no prose anywhere. RELEASES.md, the docs/plan-*.md arc plans and the versioned entries below are left alone: they record what was true when they were written, and a record edited to agree with the present is not one.

Fixed#

  • The rules were rewriting indented code, and the module said so in a comment. segment.ts left blocks indented four spaces to the rules "because they are ambiguous in markdown". The ambiguity is real. What it cost was not proportionate to it — three corruptions at once, all measured at the aggressive level:

    beforeafter
    const label = "please keep";Const label = " keep";
    def run(x):Def run(x):
    SELECT … WHERE note = 'please refund';… = ' refund';
    {"reason": "please cancel"}{"reason": " cancel"}

    The indentation goes, which by itself makes the Python a syntax error. Keywords are sentence-capitalised, which makes the rest of them syntax errors. And string literals are edited — that SQL now matches a different value and that payload carries a different reason. The report said tokens were saved.

    The blank line is what makes this a rule rather than a guess: CommonMark says an indented code block cannot interrupt a paragraph, so a run of indented lines after a blank line is code by the specification. Prose that merely wraps is still trimmed, and so is a three-space indent, which markdown reads as a paragraph.

  • A trim ran after unmasking, so it could edit what every mask had just promised to protect. optimize ended with unmask(current, vault).trim(), on the reassembled string, where a protected span is ordinary text again. A prompt opening with indented code lost that indentation there, outside every guard, invisibly — the trim is the last thing that happens. It trims the masked string now, where a protected span is a placeholder nothing can reach.

    Found through idempotence rather than through a report: the block stopped looking like a block, so the next pass no longer protected it and the rules ate the code. The fuzzer found 54 of 1,500 corpus inputs that way.

    Two limits are pinned rather than left to be discovered. Content indented four spaces inside a deeply nested list is continuation, not code, and this protects it — unsaved tokens in a rare shape against a broken prompt in a common one. And a document reduced to nothing but the block cannot be re-protected on a second pass: claiming an indented first line was tried and broke thirty-two protected spans elsewhere, because a line starting with a tab is not necessarily code. Both have tests that say so.

    Five plants fire. Two were silent first: one relabelled the mask instead of removing it, and one loosened the indent to three spaces and broke nothing — which was a real hole, since no fixture held the boundary between an indented block and ordinary wrapped prose. There is one now.

Fixed#

  • The optimiser broke email addresses, and reported a saving for it. Five of ten realistic addresses came out corrupted: please@example.com became @example.com, and so did thanks@, basically@, essentially.ops@ and very.important@. The politeness, filler and intensifier rules read the local part as ordinary prose and cut it out. What is left is not a wrong address — it is not an address.

    That is the failure segment.ts opens by naming: "compressing a code block, a URL or a template placeholder would break the prompt, and that is exactly the failure that makes a prompt optimiser useless." Code, URLs, placeholders, inline spans and XML tags were on the protected list. The thing every support prompt in the world carries was not. support@ and no-reply@ survived, and por.favor@ejemplo.es survived only because the Spanish politeness entry is written with a space rather than a dot — luck, spread across the half of the cases that happened not to spell a stripped word, which is what hid it.

    A fuzzed corpus built for exactly this failed to catch it, for a reason worth naming. hostile-input.test.js asserts every protected span survives byte for byte over a seeded corpus, and its span extractor was written from the same list as the masker — so a protection the masker did not have was one the guard could not miss. Its own comment states the principle it was missing: bait must be "text a rule would rewrite, deliberately inside protected spans", or the property can never fail. There is now an email bait atom and the extractor reads addresses.

    Three plants fire, two of them through the corpus guard. A fourth could not be built and is recorded rather than left as an untested corner: widening the pattern to \S*@\S* changes no output, because it cannot cross whitespace and a word a rule strips is its own token.

  • That email mask shipped with a quadratic quantifier, and CI caught what this machine did not. The local part accepts ., so on a long dotted run with no @ an unbounded + matched the whole run from every starting position and then failed: 897ms on 40,008 characters. security.test.js has a 5,000-second-cliff detector over the whole of optimize, and one pattern eating 18% of that budget passed here and failed on a runner about six times slower. Bounded to RFC 5321's limits — 64 octets for a local part, 63 for a label — the same input takes 8ms and no address is lost.

    A cliff detector that only fires on slow hardware is one a fast development box walks past, so there is a second guard on segment alone, where the cliff is sharper. Its fixtures are deliberately only inputs the masker should find nothing in, so any time spent is time wasted: the worst is 9ms, the budget is 300, and the fault it was written for took 897. Restoring the unbounded quantifier fails it on this machine, which is the point.

    That restriction was itself a correction. The first version of this claimed "every mask over every adversarial input", which is false: the ReDoS list in the same file includes one input where the masker takes 341ms doing exactly the work it should — fifteen thousand genuine placeholder, tag and span matches. Folding real work into a cliff budget forces the ceiling past two seconds and blunts the detector to uselessness, so that input stays where it was and this list says why.

    Two fixtures were added for the shape the old list was missing: a mask that keys on a delimiter needs a long run of the characters before it, so the pattern restarts and fails at every position. The previous fixtures were repeated whole tokens, which exercise the happy path rather than making a match fail as late as possible — the file's own note says so, about the last time this happened.

    A third guard caught the comment explaining all this: trusted-hosts.test.js scans source for hostnames and requires each to have been decided about, and it cannot tell an illustration in a comment from an endpoint. It was right to ask; the illustration is described in words now.

  • The schema reader named four formats in its own filter and could read one. findRestatedFormat reports a prompt that shows its output schema in a fence and then walks the same fields again in prose. Its fence filter admitted json, jsonc, json5, yaml and yml — and the key extractor accepted only a quoted string followed by a colon, which is JSON and nothing else. A prompt writing its schema as YAML matched a language this module names, then produced zero keys and reported nothing, however thoroughly the prose restated it. Not a missing feature: a promise made in one expression and broken by the next.

    ts was not on the list at all, which is the same omission wearing a different label — interface Ticket { … } is how a TypeScript codebase asks for structured output. Five fence shapes read correctly now where one did.

    The first implementation walked line by line and found nothing in three of them, because interface Ticket { category: string; urgency: number } is one line and a line-oriented walk sees depth 0 where it starts. Single-line objects are the normal case in a ts fence and in pasted JSON5, not the exception. It reads characters now.

    Four clean prompts hold the other direction: a nested object's fields are not top-level keys, a ts function's parameters live in parentheses rather than braces, YAML children belong to their parent, and a fence with no language stays quoted-only — an unlabelled block is as likely to be a log as a schema.

    Five plants fire. One was silent and found a hole in the fixture rather than the code: the unlabelled-fence case had no braces, so it never reached the branch the exclusion protects, and removing the exclusion left it green. A braced version was added and it fires.

Fixed#

  • The example detector was blind to nine of fourteen labellings, and six analyses went blind with it. findExamples splits a prompt into its few-shot examples, and its opener vocabulary was example, input, user, usuario, q. A support prompt labelled Customer: / Agent: — the commonest shape there is — split into nothing. So did Human:, which is Anthropic's own historical convention, and Question:, while Q: worked, which is the arbitrariness that gives the fault away. So did Cliente: and Pregunta:, in a product that ships a Spanish locale.

    Six analyses read that splitter. On a 338-token support prompt whose examples are 38% of it, profile reported the examples as costing nothing, the redundant-example advisory never fired, and trazum prune — whose whole job is cutting few-shot examples — printed "This prompt has fewer than two few-shot examples, so there is nothing to compare." That is not a refusal naming what is missing. It is a confident false statement about a prompt with four examples in it.

    The failure was silent by construction, which is why it survived: an unrecognised label yields no blocks, no blocks yields no finding, and nothing distinguishes that from a prompt containing no examples. The whole suite was green with nine of fourteen labellings blind, and is green now — no test covered it, because a test written from the same list as the code would have agreed with it.

    The vocabulary is two named lists now, openers and answerers, and both the splitter and the field pattern are built from them — the pair had already drifted once, which is exactly how the field detector came to know question while the splitter did not. The guard is fourteen real labellings written as prompts rather than as a list of labels, so it fails if the vocabulary narrows again for any reason. Four plants fire: the old vocabulary restored, an answerer label promoted to a splitter (which halves every example), the field pattern unhooked from the lists, and a suffix loosened until the splitter invents examples in ordinary prose.

  • The tag Anthropic's own documentation tells people to use found nothing. <example> is the convention in the provider's prompting guide, and this product's headline model is Claude. A code-review prompt wrapping three demonstrations in it split into zero examples, so the same six analyses went quiet that Customer: had silenced — on that prompt the examples are 68% of it.

    Tried before the label tiers, because a delimiter admits no judgement: either the tag is there or it is not, where a label is a word that might be prose. Only example and examples, which are what the documentation names — <sample> and <demonstration> exist in the wild and are not added, because that list would be a guess about what people might write, and this splitter has been burnt once already by a vocabulary somebody thought was wide enough. A tag inside a fenced block is documentation about the tag rather than a use of it, so fences are removed before matching.

    Four plants fire. One was silent at first and the plant was the fault, not the guard: it added dotAll to a pattern containing no ., which changes nothing. The real violation — a greedy body, so the first tag swallows through to the last — fires on three tests.

  • trazum prune stated something false with confidence. On a prompt it could not read it printed "This prompt has fewer than two few-shot examples, so there is nothing to compare" — a claim about the prompt, made by a tool that had only established something about itself. It now names what it looked for (a tag, or labelled turns) and says that examples laid out another way were not seen rather than not there. Both locales. That is the difference between a refusal and a wrong answer, and the doctrine asks for the first.

  • One shape is deliberately still unread, and it is written down. Inline mappings — 1. "package never arrived" -> shipping — are the remaining silent case on these probes and are not detected. The only thing separating a demonstration from an instruction there is judgement: if the ticket is about delivery -> use the shipping category has the identical shape and is a rule. Getting that wrong is not a wrong number, because prune removes what it finds, so a rule misread as an example becomes a proposal to delete an instruction. The tempting narrowing — require the left side to be quoted — was refused: both probes are quoted because the person writing the probes wrote them that way, and a threshold fitted to one's own fixture has been measured against nothing.

  • The contradiction detector missed eight of eleven ordinary phrasings, and no concept was missing. Every one sat inside an axis it already claims to cover — it was the same instruction in different grammar. "Respond in the same language the user writes in" was invisible because the pattern accepted used, wrote and speaks but not the present tense, so a prompt pinning English and mirroring the user in the same breath reported no conflict at all. So did "keep answers short" against "keep it short", "answer in at most two sentences", "provide a thorough explanation" against "be thorough", "walk through your reasoning", "show your chain of thought" and "without justification".

    The first fix traded false negatives for false positives, and measuring caught it. Widening the vocabularies made four of five clean prompts report a contradiction: a detailed error message read as a detailed answer, a word limit on a form field read as a limit on the reply, a document in the user's language read as an instruction to mirror it. The cause was dropping a constraint the module already had and documents — that the sentence must be about the response, which is what RESPOND exists for. Rebuilt so every new alternative carries its own anchor and no existing alternative is touched: eleven of eleven phrasings seen, five of five clean prompts left alone.

    The guard holds both directions, because a detector is only as good as its quieter half. Five plants fire. One was silent and found a hole in the fixture rather than in the code: the clean prompt it tested paired two sentences that both fail to match, so they masked each other and the case passed however the length cap behaved. One end of a pair has to be beyond doubt for the other end to be under test.

  • One filler family covered two constructions in English where Spanish covered five. English had four entries in the note-and-mention family and two constructions — it is important to note that and it is worth noting that, each written twice for the contraction — while Spanish had five constructions in five entries. German carried es sei darauf hingewiesen, dass, literally "it should be noted that", which English did not. Found by reading across the sections of one list rather than by taste.

    A correction to the commit that made this change. It claimed the English list was the thinnest in the file, and that is false: counted per language it is the longest, 12 entries against Spanish's 12 and Italian's 9. The gap was inside one family and the claim generalised it to the whole list without checking — a number that could not be justified, in a release note about a dictionary. Counting all six sections of all ten dictionaries took one script, and it says English is first or second in every one of them. The source comment and the guard now say what was actually measured.

    Measured on fifteen padded sentences an editor trims without touching a single instruction, the rules recovered 34 of 76 tokens. The five phrasings another language's section already justified take it to 49. Nothing was added for the other five languages: a phrasing they lack is for whoever reads the language to judge, which is what docs/language-maintainer.md exists for, and guessing at French filler from an English ear is how a rule starts editing prompts it does not understand.

    One of the fifteen caught the person doing the measuring, not the code. The corpus was graded against an editor's rewrite, and that editor turned "feel free to ask a clarifying question" into "ask a clarifying question" — which is not a trim. It converts permission into an instruction. Three of the remaining misses are the same kind and stay missed on purpose: removing try to strengthens an instruction, and make sure that you is emphasis, which this repository already decided belongs at the aggressive level. as mentioned above and keep in mind that stay out for a different reason — no other language's section justifies them, and the rule for these additions is that one has to.

    The guard holds both halves. Five plants fire, three of them for phrasings wrongly added.

  • A measured negative result, recorded so nobody re-derives it. The redundancy threshold is 0.7 word overlap, and the obvious next thought is to lower it and catch paraphrases. It was measured and it does not work: four support answers that any reader calls one example — "Let me look that up for you. Could you share your order number?" against "Of course. What is your order number?" and two more — overlap at 0.29–0.43, and comparing only the answers makes it worse, 0.21–0.39, because all they share is your, order, number. No threshold separates those from genuinely different examples. That judgement belongs to trazum semantic, which says what it costs and asks first, and to prune, which answers it by running the cases. The deterministic half reports what the examples cost, which is a fact.

  • The release document asked a question the release had already answered. Since 1.85.0 it said which credential authenticated the npm upload was unsettled, because provenance is signed with the job's OIDC identity either way and proves nothing about the auth. The 1.86.0 run answers it: the Can this workflow authenticate to npm? step reported all four packages rejected, and all four published seconds later in the same job. The only other credential there is the granular token on the release environment, so that token is what authenticates every upload — it is the thing holding releases up, not a fallback in waiting, and deleting it stops them.

    That also settles what 1.85.0 could only narrow. @trazum/tokenizer-openai published although the token was made when three packages existed, and the two explanations were OIDC or a wider scope. OIDC is now ruled out for that package by name, so the scope is wider than three. The rule about regenerating the token when a package is added stays, because a scope nobody has inspected is not one anybody can rely on.

    The workflow said the same thing in the older, weaker form — "when npm keeps refusing", as a conditional about a fallback. Two comments now state what is actually true of every publish this repository makes.

  • The README told people to pin an Action two releases old. security.test.js derives how many versions a recommended pin is behind from git tag, and allows exactly one — the pin can only advance to a release commit once that commit exists, which is after the merge rather than in it. 1.85.0 shipped and left the pin at 1.83.0, which the rule tolerated; 1.86.0 made it two and the guard fired.

    It fired on CI and not here, and the reason is the same class of fault this release spent a commit on. The container running the tests had fetched tags before v1.86.0 existed, so git tag listed one release since the pin and the guard passed. A test whose verdict depends on how recently the machine fetched is environment-dependent in the way SPAWN_ENV was written to stop — though here the machine is behind the truth rather than differently configured, and the fix is fetching, not neutralising. Reproduced locally by fetching the tag, then fixed.

    The pin is the 1.86.0 release commit now. Planted a wrong label against the right commit to check the fix advanced the pin rather than blinding the guard: it still fails with comment says 1.85.0, 2c5e907 says 1.86.0.