Skip to content

fix: a write refuses importance outside 1-10 on every type (#1537) - #1570

Merged
markramm merged 11 commits into
devfrom
fix/1537-importance-range-every-type
Nov 17, 2026
Merged

markramm merged 11 commits into
devfrom
fix/1537-importance-range-every-type

Conversation

@markramm

@markramm markramm commented Nov 17, 2026 •

Copy link
Copy Markdown
Collaborator

Groom 2026-11-16

Automated groom (architect agent, working for the maintainer). Written so someone new to Pyrite can start from this issue alone. "Checked" means I ran the command or read the line on bccf8f7.

The user's model. "Importance is 1 to 10. If I send 99, Pyrite tells me, whatever kind of entry it is."
The implementation model. One range rule, on the base entry, reached by every write through the one write gate. Design principle 8 (kb/design.md): each rule lives in one place.
The difference today. The rule sits on one subclass. The gate that calls it already runs for every type.

Contracts that apply

  • kb/design.md principle 8: a rule is enforced at the single point everything passes through.
  • kb/design.md principle 2: a hand-edited file is never refused or repaired for what it already holds. An update that leaves a bad value alone must still succeed.
  • docs/json-contracts.md, "canonical error shape": the refusal is VALIDATION_FAILED with an errors row (field, rule, message, expected).
  • kb/maps/types-and-schema.md: its first invariant (write path and qa validate agree) covers enums only. No sibling for ranges is written anywhere; 0.26.4 theme T1: a type is one schema per KB #1528 slice T1-4 writes it. Not this issue's job.

What the code does today (checked)

  • pyrite/services/kb_service.py:759 KBService._validate_write is the write gate. Create (:1589) and every update path (:1724, :2321, :2350) call it, and it calls entry.validation_errors() for every type. So the enforcement point exists and every surface passes it.
  • pyrite/models/core_types.py:198 EventEntry.validation_errors is the only place the range is checked on a write (:221-232, calling validate_importance, pyrite/schema/validators.py:103).
  • pyrite/models/base.py:724 Entry.validation_errors checks id and title only. importance is a base field (:287), carried by all of the about 40 entry classes (13 in core).
  • Surprise: a third copy. extensions/journalism-investigation/src/pyrite_journalism_investigation/validators.py:142-150 has its own range check, which runs only in a KB registered with that plugin's type. tests/test_plugin_contract.py:403-446 uses it.
  • pyrite/services/qa_service.py:915 _check_importance_range and :1179 report the same rule after the fact, as a warning.
  • REST bounds the top-level field in pydantic (pyrite/server/schemas.py:467, :484, ge=1, le=10). MCP only describes it (pyrite/server/tool_schemas.py:784, :844, :874). The CLI has no bound on --importance (pyrite/cli/entry_commands.py:318, :565) or on -f importance=.
  • The on-disk case already works for events (checked). With importance: 99 hand-written into an event file, pyrite update vote -k res -f location=Hall succeeds and returns a warning: "rule": "model_validation", "message": "Importance must be 1-10, got: 99", "note": "violation already on disk; kept". That is _validate_write's prior_model_errors (:783-807). Moving the rule to the base class gives every type this behaviour with no new code.

Invariant and surfaces

A write never stores an importance outside 1-10, on any type, by any surface. A value already in the file is reported, not refused.

Surface Today Evidence
CLI create/update -f importance= fails for non-events steps above
CLI create/update --importance fails for non-events #1393; PR #1428 adds a usage error in front
MCP kb_create, kb_update fails for non-events audit H3 probe (99, then 77); not re-run here
REST create/update, top-level importance holds pydantic bound (read)
REST, importance inside metadata not checked assumed to fail; the test below settles it
pyrite add <file> an event file is refused today; other types are not read (:1589), not run
Plugins journalism KBs refuse through their own copy read
Hand edit + index sync not a write by Pyrite; qa validate reports it must stay so

Shapes (parametrise the test over these):

Shape Count How counted
Entry classes about 40 (13 core) grep -rnE "^class \w+\(" pyrite/models/*.py extensions/*/src/*/*.py | grep -c Entry
Types defined by kb.yaml alone (GenericEntry) 1 class, any name read
Values in range (1, 10); out (0, 11, -5, 99); "7"; "high"; absent the event rule's own cases
Operation create; update setting it; update of another field over a bad value on disk; add _validate_write callers
importance: in this repo's own files 369 lines, 368 in range, 1 template placeholder (<1-10>) git grep -hE "^importance:" -- '*.md' | sort | uniq -c

Options

  • A. Move the range row from EventEntry.validation_errors to Entry.validation_errors (recommended). About ten lines moved. Every type and surface is covered by the gate that already runs; the on-disk exception comes with it. kb_service.py is not edited.
  • B. Check in _validate_write. Same effect, but it edits kb_service.py, which is the busiest file in the tree this month (0.26.4 themes: order of work #1533, "Files that force a series"), and puts a model rule in the service.
  • C. Wait for 0.26.4 theme T1: a type is one schema per KB #1528 T1-4 (one value check behind type_spec). Right end state, about three weeks out, and importance is a base field whose range does not depend on the type.

Open questions

  • Should qa validate report importance_range as an error, now that a write refuses it? Today it is a warning. Leave it unless the maintainer says otherwise; note what you find.
  • The journalism plugin's copy becomes unreachable for a write (the model check raises first). Remove it here, or leave it for 0.26.4 theme T2: a plugin passes the same single points as core #1529? If you remove it, tests/test_plugin_contract.py::TestValidateWritePrefersMessage needs another rule-less validator to exercise.
  • pyrite add of a hand-written file with importance: 99: refused, as an event file is today. Say so in the changelog fragment. If you find that this breaks an import path, report it instead of working around it.

Pointers

pyrite/models/core_types.py (EventEntry.validation_errors), pyrite/models/base.py (Entry.validation_errors, unrepresented_frontmatter), pyrite/services/kb_service.py (_validate_write, read only), tests/test_enum_enforcement.py (a write-gate test over surfaces), tests/conftest.py (cli_world), tests/_world.py.

Checked versus assumed

  • Ran: every command above; the on-disk event case.
  • Read, not run: MCP and REST paths, pyrite add.
  • Assumed: no entry class overrides validation_errors without calling super() (grep finds one override, EventEntry, which does call it).
  • This groom is wrong if some type or importer relies on storing 0 or a value above 10. I found none in pyrite/, extensions/ or the shipped templates.
  • Predicted footprint: pyrite/models/base.py, pyrite/models/core_types.py, one new test file, one changelog.d/*.changed.md fragment. About 60 lines with tests. If it grows past four source files, stop and say why.
Acceptance:   create and update of a non-event with importance 0, 11, -5 or 99 are refused on the CLI
              (-f importance=) and on MCP kb_create/kb_update with VALIDATION_FAILED and an errors row
              naming importance; no file is written or changed. 1 and 10 are accepted. An update of
              another field on a file that already holds importance: 99 succeeds with the
              "violation already on disk; kept" warning. The event behaviour is unchanged.
              Fails today: the person create in "Steps" exits 0.
Regimes:      value already out of range on disk (kept, warned); importance absent (default 5, accepted);
              non-numeric value in a hand-written file ("high": kept, as for events today);
              a kb.yaml-only type; a plugin type.
Shapes:       the table above; one test parametrised over type x value x operation.
Touches:      existing: pyrite/models/base.py, pyrite/models/core_types.py
              new: tests/test_importance_range_on_every_type.py, changelog.d/<slug>.changed.md
Sequence:     independent. PR #1428 (#1393) edits pyrite/cli/entry_commands.py only and stays in front
              as a usage error (exit 2) for --importance; write this issue's tests with -f importance=
              and MCP so the two do not collide. #1502 is the list-field half of the same audit finding
              and is separate. #1528 T1-4 later moves this rule behind type_spec; if #1528 T1-0's
              value matrix has landed, remove its expected-failure marker for the importance row here.
Model:        sonnet
Size:         S
heavy:        no
Cold read:    no (no new shape; an existing refusal now applies to more types)
Out of scope: list-typed fields (#1502). The CLI --importance usage error (#1393, PR #1428).
              MCP schema minimum/maximum (the service refusal is the rule; a schema bound would
              answer with a second error shape, see #1508). QA severity. Read-side --min-importance
              filters (#1412, #1474).

Fixes #1537

Report

Done. The range rule moved from EventEntry.validation_errors to Entry.validation_errors (pyrite/models/base.py, pyrite/models/core_types.py). The one write gate already calls it for every type, so create, update and add refuse an importance outside 1-10 and write nothing. A value already on disk is kept and reported ("violation already on disk; kept"). pyrite/services/kb_service.py is not edited. Branch is fix/1537-importance-range-every-type (named in the brief), not the session's default branch.

Red first. On dev the new file gave 381 failed, 258 passed, and no event row was among the failures. scripts/verify-red.sh on the branch: verify-red: 381 red · 0 import-only · 0 unexpected pass · 0 n/a · 258 control. The controls are the event rows, event subclasses, and the in-range and absent values (an over-refusal guard).

validation_errors overrides. A grep of pyrite/ and extensions/ finds two definitions: Entry (base.py) and EventEntry (core_types.py). EventEntry calls super(). No class overrides it without super(), so the groom's assumption holds.

One change beyond the groom. The importance row now comes from the base class, so an event's rows would have come out importance, date. tests/test_write_refusal_names_the_field.py pins ["date", "importance"], so EventEntry now puts its date row before the importance row, as before.

Surfaces (the groom's table).

Surface Now
CLI create / update -f importance= ran: refused on every type, VALIDATION_FAILED, exit 1, nothing written
MCP kb_create / kb_update ran: same
CLI --importance not run; PR #1428 owns it
REST top-level importance read only: the pydantic bound (pyrite/server/schemas.py) is unchanged
REST importance inside metadata not run; reaches the same gate, not settled by a test here
pyrite add <file> ran: refused for a person with importance: 99 (the test also covers an event file); no file is written
Plugin KBs ran: a journalism KB gets the model's answer (see below)
Hand edit + index sync unchanged; qa validate still reports it

Types covered. Surface tests run over the core registry, one plugin type (zettelkasten) and a type declared only in a kb.yaml (widget), on both the CLI and MCP. A separate test runs test_every_entry_class_carries_the_rule over every registered class (core, all plugin, generic), so a new type cannot skip the rule.

pyrite add. It refuses a hand-written importance: 99 on a non-event, as it already did for an event, and the changelog fragment says so. I searched pyrite/ and extensions/ for importance values outside 1-10 and for computed values: none. No import, init-template or example path stores one, so there is no "Decision needed" for this.

Caller-visible change on a journalism-investigation KB (create ... -f importance=99 on a person):

Before Now
CLI exit 1, SCHEMA_VIOLATION exit 1, VALIDATION_FAILED
MCP kb_create SCHEMA_VIOLATION VALIDATION_FAILED
Service exception SchemaViolationError ValidationError
errors row {field, message}, no rule {field, rule: "range", message, expected: "1-10"}

The fragment says so in one sentence, and test_a_journalism_kb_refuses_importance_99_with_the_models_answer pins it on both surfaces.

The conductor's directed change to tests/test_plugin_contract.py.

  • TestValidateWritePrefersMessage now registers its own plugin, with a validator that returns a message and no rule. It asserts the message survives. Plant: make _validate_write ignore message (the elif message: branch in kb_service.py). Red: TestValidateWritePrefersMessage::test_a_rule_less_validator_message_is_not_lost and TestValidateWriteKeepsEnumDetail::test_a_ruleless_error_uses_its_message.
  • test_plugin_validator_error_is_non_zero_not_silent now uses a payment transaction with no amount, which only the journalism validator enforces. Plant: run_validators returns []. Red: that test, plus 6 others in the file that depend on plugin validators.
  • Both docstrings are updated. Every plant was reverted; nothing planted is committed and kb_service.py is not in the diff.
  • I checked that the journalism validator's importance item was the only one without a rule.

Tests.

  • Affected suite before the test rewrite: 3 failed, 23510 passed (the three were the two plugin-contract tests plus the row-order one, which is now fixed).
  • Extra files plus every extension's tests, run once after the rewrite and the merge: 1942 passed. This covered the new file, tests/test_enum_enforcement.py, tests/test_plugin_contract.py, tests/test_response_text_is_pyrites.py, tests/test_write_refusal_names_the_field.py and extensions/*/tests.
  • Pre-push hook (full suite) passed on the final push. No extension fixture stored an out-of-range importance.
  • The known cloud failures and the two timing tests did not occur.

Pushed SHA. dc213bd142b7d3be6e40eff8f202bf50af09151a, equal to git ls-remote origin fix/1537-importance-range-every-type. origin/dev was merged in (a merge commit) before the last push.

Unsure.

  • The first push was refused by the pre-push hook because of the two plugin-contract failures. I stopped and commented instead of using --no-verify.
  • high as a value on create or -f update is not in the refused set: events already stored the default for it, so I kept that behaviour. Only a hand-written high is kept and reported.
  • The maintainer's call: should qa validate keep reporting importance_range as a warning? I saw it still reads the index, so it only reports hand-edited files now.

Left.

Learned.

  • The groom was right that no override skips super().
  • It missed that two plugin-contract tests, and one event row-order test, depended on the old rule's position.
  • SchemaViolationError is a subclass of ValidationError, so callers catching the latter see no break.

Captured in. tests/test_importance_range_on_every_type.py (every item above that is behaviour), tests/test_plugin_contract.py docstrings, the changelog fragment, and the comment on the date-row insertion in EventEntry.validation_errors.

Tokens. Not reported.

Fixes #1537

Report, round 1

Head 55fb3fe698bfb71ae35b8e0cc8eacbbd25aaf185 (git ls-remote origin fix/1537-importance-range-every-type returns the same SHA). origin/dev is merged (a merge commit). The pre-push hook's full run passed.

The value matrix

I measured every cell with one script on dev (the head with base.py and core_types.py put back to origin/dev) and on the new head, through the CLI and through MCP _dispatch_tool. The events give the same answers as the notes on the new head. On dev, the only event differences are the crashes and the refusals the event rule already had.

Cells are dev -> head (note; an event gives the same answers on head). ok = succeeds, +W = with the importance warning, refused = VALIDATION_FAILED, CRASH = NO_OUTCOME/INTERNAL; (x) = what the file then holds.

value 1 update other 2 CLI set 3 CLI create 4 add 1 MCP other 2 MCP set 3 MCP create
in_range_7 ok ok (7) ok (7) ok ok ok (7) ok (7)
out_99 ok -> ok+W ok (99) -> refused (5) ok (99) -> refused ok -> refused ok -> ok+W ok (99) -> refused (5) ok (99) -> refused
zero ok -> ok+W ok (0) -> refused (5) ok (0) -> refused ok -> refused ok -> ok+W ok (0) -> refused (5) ok (0) -> refused
big_30_digits CRASH CRASH (123456789012) -> refused (5) CRASH (123456789012) -> refused CRASH -> refused CRASH CRASH (123456789012) -> refused (5) CRASH (123456789012) -> refused
float_5.0 ok ok (5) ok (5) ok ok ok (5) ok (5)
float_10.0 ok ok (10.0) ok (10) ok ok ok (10.0) ok (10)
float_5.5 ok ok (5.5) ok (5) ok ok ok (5.5) ok (5)
inf ok -> ok+W ok (".inf") -> refused (5) ok (5) ok -> refused ok -> ok+W ok (.inf) -> refused (5) ok (5)
-inf ok -> ok+W ok ("-.inf") -> refused (5) ok (5) ok -> refused ok -> ok+W ok (-.inf) -> refused (5) ok (5)
nan ok -> ok+W ok (".nan") -> refused (5) ok (5) ok -> refused ok -> ok+W ok (.nan) -> refused (5) ok (5)
true ok -> ok+W ok (true) -> refused (5) ok (1) ok -> refused ok -> ok+W ok (true) -> refused (5) ok (1)
false ok -> ok+W ok (false) -> refused (5) ok (0) -> refused ok -> refused ok -> ok+W ok (false) -> refused (5) ok (0) -> refused
null ok ok ("null") -> refused (5) ok (5) ok ok ok (null) ok (5)
blank ok ok ("") -> refused (5) ok (5) ok ok ok (null) ok (5)
empty_string ok -> ok+W ok ("") -> refused (5) ok (5) ok -> refused ok -> ok+W ok ("") -> refused (5) ok (5)
str_5 ok ok (5) ok (5) ok ok ok ("5") ok (5)
str_sp5sp ok ok (5) ok (5) ok ok ok (" 5 ") ok (5)
str_05 ok ok (5) ok (5) ok ok ok ("05") ok (5)
high ok -> ok+W ok (high) -> refused (5) ok (5) ok -> refused ok -> ok+W ok (high) -> refused (5) ok (5)
abc ok -> ok+W ok (abc) -> refused (5) ok (5) ok -> refused ok -> ok+W ok (abc) -> refused (5) ok (5)
list ok -> ok+W ok (importance:) -> refused (5) ok (5) ok -> refused ok -> ok+W ok (importance:) -> refused (5) ok (5)
mapping ok -> ok+W ok ("{a: 1}") -> refused (5) ok (5) ok -> refused ok -> ok+W ok (importance:) -> refused (5) ok (5)
date ok -> ok+W ok ("2026-01-02") -> refused (5) ok (5) ok -> refused ok -> ok+W ok ("2026-01-02") -> refused (5) ok (5)

Classification of every changed or crashing cell:

  • Fixed here: .inf / -.inf on disk and on add (CRASH to kept+warning / refused); .inf set over MCP (CRASH to refused); true; null and blank on disk.
  • Guarded by a test: every cell above is a test in tests/test_importance_range_on_every_type.py, one per kind × note/event × CLI/MCP × file / set / create / add (test_a_value_already_on_disk_never_stops_an_update_of_another_field, test_a_set_importance_is_refused_or_in_1_to_10, test_a_created_importance_is_refused_or_stored_in_1_to_10, test_add_refuses_a_file_holding_a_bad_value_and_accepts_the_rest, test_the_check_never_raises_and_says_row_or_nothing). The KINDS table has one row per kind with the verdict written by hand from the property; a new kind cannot be added without a verdict.
  • Not fixed, pre-existing: a 30-digit whole number already in a file crashes an update of another field with NO_OUTCOME / INTERNAL, on dev and on this head. The check answers with a row; the crash is in the index upsert (pyrite/storage/crud.py to base_backend.py, OverflowError: Python int too large to convert to SQLite INTEGER) after the file has been written. It is four xfail(strict=True) cells so it flips when fixed.
  • Safe by reading: the unchanged ok cells (in range, whole floats, numeric strings) hold on both trees. 5.5 is accepted on both because int(5.5) is 5, which is within the stated limit.

What I decided

  • Blank and null importance are absent: no row, on every path (Entry.validation_errors in base.py). pyrite add already accepted them; the "kept" warning about None on every later update is gone. importance: "" (an explicit empty string) is a non-number and gets a row. Explicitly setting null over MCP writes importance: null as on dev; it reads as absent.
  • .inf, -.inf, .nan are non-numbers: a row, never an exception. The mechanism: validate_importance (pyrite/schema/validators.py) is the one place a value becomes "in range or not", and it cannot raise. It catches OverflowError besides ValueError and TypeError. A bool is not a number (true used to pass as 1), so true and false are rows. qa_service calls the same function, so the QA check cannot raise on one either.

Final fragment (changelog.d/1537-importance-range-every-type.changed.md)

  • A write no longer stores an importance that is a number outside 1 to 10 or not a number, on any entry type. Until now only event entries refused one; every other type stored it, and pyrite qa validate then warned about what Pyrite had just written. Now a create, an update that sets it, and pyrite add of a file that holds it are refused with VALIDATION_FAILED and an errors row naming importance (rule: range, expected: 1-10), and no file is written or changed, on the CLI (-f importance=) and on MCP kb_create / kb_update. What changes for a non-event entry: 0, 11, -5, 99 and 30-digit numbers are refused (they were stored); update -f importance=high or =abc, and an MCP kb_update with a non-number importance, are refused (they wrote the text into the file as given); true, false, .inf, -.inf, .nan, a list, a mapping and a date count as non-numbers and are refused too, and true no longer passes as 1 on an event; pyrite add of a file whose importance is high, [5], {a: 1}, 0, true, .inf or any other non-number or out-of-range value is refused (it was accepted). A numeric string ("5", " 5 ", "05") and a whole-valued float (5.0, 10.0) are accepted, as before. A blank or null importance: in a file is absent, not a violation: pyrite add accepts it and an update of another field says nothing about it.
  • A value already in a file is kept and reported. An update of another field on a file whose importance is out of range or not a number succeeds and returns a "violation already on disk; kept" warning, and never touches that line. On an event, .inf and -.inf used to crash that update (NO_OUTCOME on the CLI, INTERNAL on MCP); they now answer as every other value does. The one value that still stops it is a 30-digit whole number, which the index cannot store (the command answers NO_OUTCOME; it did on 0.26.3 too).
  • Two limits, unchanged: create -f importance=high (or abc, .inf, true, a blank) still stores the default 5 or 1 without saying so, and update -f importance=5.5 still writes 5.5 as given.
  • In a journalism-investigation KB the refusal used to come from the plugin as SCHEMA_VIOLATION (SchemaViolationError, a row with no rule); it now comes from the model as VALIDATION_FAILED (ValidationError), the same answer as every other type (A write accepts importance outside 1-10 on every type except event (-f importance=99, MCP kb_create) #1537).

Tests

  • tests/test_importance_range_on_every_type.py: 1005 passed, 4 xfailed. With the round-1 change removed (the dc213bd validators.py and base.py put back): 48 failed, 957 passed, 4 xfailed (12 set, 20 on-disk, 6 add, 10 check).
  • Affected suite: 24118 passed, 256 skipped, 7 xfailed.
  • Alone: the new file, tests/test_plugin_contract.py, tests/test_write_refusal_names_the_field.py, tests/test_response_text_is_pyrites.py and extensions/*/tests together: 2214 passed, 4 xfailed.
  • pyrite/services/kb_service.py is not edited.

Unsure

  • Treating a bool as a non-number changes an event with importance: true on disk from silent to a "kept" warning, and pyrite add of it from accepted to refused. The fragment says so.
  • The create column is only "refused, or what is stored is in 1-10", because create turns a non-number into the default before the check. I did not pin the silent conversion as correct.
  • Footprint: three source files (pyrite/models/base.py, pyrite/models/core_types.py, pyrite/schema/validators.py), under the four-file limit; kb_service.py is untouched.
  • Correction to my earlier Unsure line: update -f importance=high on a non-event is refused on this head (for events it was already refused on dev).

Left (one line each, for follow-up issues)

  • create turns a non-number (high, .inf, true) into 5 or 1 without a report;
  • update -f importance=5.5 writes 5.5 as given;
  • REST's top-level importance answers FastAPI's own 422, not Pyrite's VALIDATION_FAILED row;
  • the "kept" warning row carries rule: model_validation where the refusal row says range;
  • the journalism plugin's own importance check (now unreachable on a write, and adding a second warning) stays for 0.26.4 theme T2: a plugin passes the same single points as core #1529;
  • qa validate does not see a non-number on disk;
  • a 30-digit importance on disk crashes the index upsert after the file is written (dev as well).

Learned

  • The groom's invariant was about numbers. Whatever a file can put in the field reaches the check, so "never raises" needs a cell per kind of value, not per number.
  • validate_importance had no OverflowError guard, so int(float('inf')) crashed every write path that touched the entry, on events on dev too (validators.py).

Captured in

The KINDS table and its five tests; the docstring of validate_importance; the comment on the blank/null rule in Entry.validation_errors; the fragment.

Tokens

Not reported.

Fixes #1537

Report, round 2

Words-only change at 0580fac (fragment sentences and the test module header; no code or assertion changed).

Head d508760d63fef668c62893627b4574b76130d74f (git ls-remote origin fix/1537-importance-range-every-type returns the same SHA). origin/dev was already merged. The pre-push hook's full run passed.

New rows and the null-set column (dev -> head, note; an event gives the same answers on the head)

Same legend as round 1. The null and blank rows are the "write sets null or blank" column: the CLI cells are -f importance=null and -f importance= (text), the MCP cell is "importance": null.

value (note) 1 update other 2 CLI set 3 CLI create 4 add 1 MCP other 2 MCP set 3 MCP create
float_10.000001 ok -> ok+W ok (10.000001) -> refused (5) ok (10) ok -> refused ok -> ok+W ok (10.000001) -> refused (5) ok (10)
float_10.5 ok -> ok+W ok (10.5) -> refused (5) ok (10) ok -> refused ok -> ok+W ok (10.5) -> refused (5) ok (10)
float_10.9 ok -> ok+W ok (10.9) -> refused (5) ok (10) ok -> refused ok -> ok+W ok (10.9) -> refused (5) ok (10)
float_0.5 ok -> ok+W ok (0.5) -> refused (5) ok (0) -> refused ok -> refused ok -> ok+W ok (0.5) -> refused (5) ok (0) -> refused
float_0.99 ok -> ok+W ok (0.99) -> refused (5) ok (0) -> refused ok -> refused ok -> ok+W ok (0.99) -> refused (5) ok (0) -> refused
float_-0.5 ok -> ok+W ok (-0.5) -> refused (5) ok (0) -> refused ok -> refused ok -> ok+W ok (-0.5) -> refused (5) ok (0) -> refused
float_1e1 ok ok (10.0) ok (10) ok ok ok (10.0) ok (10)
str_10.9 ok -> ok+W ok (10.9) -> refused (5) ok (10) ok -> refused ok -> ok+W ok ("10.9") -> refused (5) ok (5)
str_1e1 ok -> ok+W ok (10.0) ok (10) ok -> refused ok -> ok+W ok ("1e1") -> refused (5) ok (5)
null ok ok ("null") -> refused (5) ok (5) ok ok ok (null) ok (5)
blank ok ok ("") -> refused (5) ok (5) ok ok ok (null) ok (5)

Events: same as notes on the head for every row above
Event rows that differ from the note on dev (the null set): [('null', 'VALIDATION_FAILED | importance: 5', 'ok | importance: null'), ('blank', 'VALIDATION_FAILED | importance: 5', 'ok | importance: null')]

Verdicts, written by hand from the property (they are the KINDS rows): the six non-whole edge numbers are "bad" on disk, on set and on add (a number is compared as it is); 1e1 is a whole-valued float, "good" everywhere; the string "10.9" is bad on every surface; the string "1e1" is bad on disk and over MCP, and good on the command line, because the CLI reads numeric text as a number (-f importance=1e1 writes 10.0); create is "refused, or what is stored is in 1-10" (a create cuts a decimal to a whole number in the model before the check, which is how 10.9 became 10 on dev too). 5.5 stays "good" and its row now says it is the stated limit, not the rule.

What I decided

  • 10.x: compare the number before truncating (your recommendation). validate_importance (pyrite/schema/validators.py) compares ints and floats as they are, reads a string only as whole-number text, tries float() for any other type, and still cannot raise. So 10.000001, 10.5, 10.9, 0.5, 0.99 and -0.5 are refused on the head, and 5.5 is still accepted as given.
  • A null set: keep it, one answer on every type. An MCP kb_update with "importance": null is accepted on a note and on an event; the file then holds importance: null, which reads as absent. It follows from "null is absent". On dev an event refused it. The CLI texts -f importance= and =null are strings, refused on every type. Pinned by test_an_mcp_update_setting_importance_null_is_accepted_on_every_type and test_a_cli_update_setting_importance_to_blank_or_null_text_is_refused, and named in the fragment.
  • The four 30-digit cells now fail as expected only for the index overflow. The cell raises _IndexOverflowError only for the NO_OUTCOME / INTERNAL answer with the file rewritten, and the xfail has strict=True, raises=_IndexOverflowError. Any other failure is a real failure. The reason names An update of an entry the index cannot store writes the file, then answers NO_OUTCOME (a 30-digit importance) #1584.
  • The 30-digit text says what happens: the update rewrites the file, the index upsert then raises, the command answers NO_OUTCOME (CLI) or INTERNAL (MCP), and the index has no row for the entry (I checked: it had none before the update either, because the indexer cannot store the value). Same on 0.26.3.

Final fragment (changelog.d/1537-importance-range-every-type.changed.md)

  • A write no longer stores an importance outside 1 to 10, or one that is not a number, on any entry type. Until now only event entries refused one; every other type stored it, and pyrite qa validate then warned about what Pyrite had just written. Now a create, an update that sets it, and pyrite add of a file that holds it are refused with VALIDATION_FAILED and an errors row naming importance (rule: range, expected: 1-10), and no file is written or changed, on the CLI (-f importance=) and on MCP kb_create / kb_update. An update that sets it and pyrite add check the number as given, so 10.000001, 10.5, 10.9, 0.5, 0.99 and -0.5 are refused there too (they were accepted: a decimal was cut to a whole number before the comparison); a create still cuts a decimal first (see the limits below). What changes for a non-event entry: 0, 11, -5, 99 and 30-digit numbers are refused (they were stored); update -f importance=high or =abc, and an MCP kb_update with a non-number importance (including the string "10.9" or "1e1"), are refused (they wrote the text into the file as given); true, false, .inf, -.inf, .nan, a list, a mapping and a date count as non-numbers and are refused too on an update and by pyrite add, and true no longer passes as 1 there on an event; pyrite add of a file whose importance is high, [5], {a: 1}, 0, true, .inf, 10.9 or any other non-number or out-of-range value is refused (it was accepted). A numeric string ("5", " 5 ", "05") and a whole-valued float (5.0, 10.0, 1e1) are accepted, as before. A blank, null or ~ importance: in a file is absent, not a violation: pyrite add accepts it and an update of another field says nothing about it. A quoted empty string (importance: '' or "") is not blank: pyrite add refuses it (a note accepted it and stored importance: ""), and an update of another field on a file that holds it reports it as kept. An MCP kb_update with "importance": null is accepted on every type (an event used to refuse it) and leaves importance: null in the file, which reads as absent; on the command line -f importance= and -f importance=null are text, not null, and are refused.
  • A value already in a file is kept and reported. An update of another field on a file whose importance is out of range or not a number succeeds and returns a "violation already on disk; kept" warning, and never touches that line. On an event, .inf and -.inf used to crash that update (NO_OUTCOME on the CLI, INTERNAL on MCP); they now answer as every other value does. One value still fails: with a 30-digit whole number already in the file, the update rewrites the file and then the index cannot store the number, so the command answers NO_OUTCOME (CLI) or INTERNAL (MCP) although the file has changed, and the index has no row for the entry. It does the same on 0.26.3 (An update of an entry the index cannot store writes the file, then answers NO_OUTCOME (a 30-digit importance) #1584).
  • Limits, unchanged: a create still turns its value into a whole number or the default before the check, without saying so. create -f importance=10.7 exits 0 and stores importance: 10, and 3.9 stores 3 (0.99 is refused only because it becomes 0); create -f importance=high (or abc, .inf, a blank) stores the default 5, and create -f importance=true stores 1, on a note and on an event. And update -f importance=5.5 still writes 5.5 as given: a number inside 1 to 10 is accepted whether or not it is whole.
  • In a journalism-investigation KB the refusal used to come from the plugin as SCHEMA_VIOLATION (SchemaViolationError, a row with no rule); it now comes from the model as VALIDATION_FAILED (ValidationError), the same answer as every other type (A write accepts importance outside 1-10 on every type except event (-f importance=99, MCP kb_create) #1537).

Tests

  • tests/test_importance_range_on_every_type.py: 1155 passed, 4 xfailed. With this round's change removed (the round-1 validators.py put back): 38 failed, 1117 passed, 4 xfailed (14 set, 12 on-disk, 6 add, 6 check).
  • Affected suite: 24268 passed, 256 skipped, 7 xfailed.
  • Alone, in one run: the new file, tests/test_plugin_contract.py, tests/test_write_refusal_names_the_field.py, tests/test_response_text_is_pyrites.py and extensions/*/tests: 2364 passed, 4 xfailed.
  • pyrite/services/kb_service.py is not edited.

Unsure

  • A bool, null and 10.x each change an answer for someone upgrading; all are in the fragment. The one I would look at twice is "null set accepted over MCP, text null refused on the CLI": it is one rule (null is absent; text is a string) but reads as two answers.
  • "1e1" as a string is refused over MCP and accepted on the CLI. That follows from how each surface hands the value over, and the matrix pins both.
  • Correction to round 1's Unsure line 3: round 1 touched two source files (base.py, validators.py); round 2 touches one (validators.py); the whole change touches three (base.py, core_types.py, validators.py).

Left (one line each, for follow-up issues)

Learned

  • Truncating before comparing is a second way a range check can be wrong; the edge of the range is where it shows (validators.py).
  • A strict xfail without raises= accepts any failure as the expected one; the cell has to raise its own marker for the known failure.

Captured in

The KINDS rows and the two null-set tests; the validate_importance docstring; the _IndexOverflowError comment and raises=; the fragment.

Tokens

Not reported.

Fixes #1537


Generated by Claude Code

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw
The range rule sat on EventEntry.validation_errors only, so every other type
stored importance 99 and qa validate then warned about what Pyrite had just
written. It now sits on Entry.validation_errors, which the one write gate
(KBService._validate_write) already calls for every type: create, update and
add refuse it; a value already on disk is kept and reported, as for events.
EventEntry's rule name, message and on-disk exception are unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw
verify-red found them passing without the fix, as intended: they guard
against over-refusal and pin EventEntry's behaviour.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw
The range row moved to Entry.validation_errors, which runs first; keep the
order an event refusal has always had (date, then importance).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw

Copy link
Copy Markdown
Collaborator Author

Stopped: my push is refused by the pre-push hook, and the red is caused by this change. Pushed head is still the claim commit 1fe21e2. Three local commits are not pushed: the fix, the controls and the event row-order commit.

The full pre-push run: 2 failed, 23511 passed, 256 skipped, 3 xfailed. Both failures are in tests/test_plugin_contract.py:

  • TestValidateWritePrefersMessage::test_importance_error_message_is_not_lost
  • TestPluginKBTaskUpdateNoTracebackNoSilentSkip::test_plugin_validator_error_is_non_zero_not_silent

Both build a journalism-investigation KB, write importance=99 on a person, and expect the journalism validator's own SchemaViolationError (the groom's open question (b)). The model rule now fires first, so they get pyrite.exceptions.ValidationError: Importance must be 1-10, got: 99.

The brief says to stop and report instead of rewriting test_plugin_contract.py, and not to use --no-verify for a related failure. I have done neither. The tests need a decision from you: change them to expect the model's refusal, or give them a different rule-less validator (the groom's suggestion).

Local state: new test file 639 passed, verify-red 381 red · 0 import-only · 0 unexpected pass · 0 n/a · 258 control, ruff clean. The full report follows once the push question is settled.


Generated by Claude Code

@markramm

Copy link
Copy Markdown
Collaborator Author

Conductor's answer to the stop on #1570 (2026-11-17). You stopped in the right place; thank you. This is a directed answer, not a review round.

The property to keep. Each of the two tests pins something about plugin validators, and importance=99 was only the trigger they used:

  • TestValidateWritePrefersMessage::test_importance_error_message_is_not_lost pins: an item a plugin validator returns with a message and no rule reaches the caller with that message (never "expected None, got None").
  • TestPluginKBTaskUpdateNoTracebackNoSilentSkip::test_plugin_validator_error_is_non_zero_not_silent pins: an error that only the plugin's validator raises comes out as a SchemaViolationError (a PyriteError), not swallowed by a signature-mismatch fallback.

Your change makes the model answer first for importance, which is the point of #1537, so neither test reaches a plugin validator any more. Keep what each pins; change only the trigger. Do not make them expect the model's refusal: that would leave both properties untested.

What to do.

  1. Second test: use a rule only the journalism validator enforces. validate_investigation_entry has several (for example a transaction whose type is payment with no amount, which returns field amount). Assert the same things as before with that field.
  2. First test: it needs an item with a message and no rule. The importance item was the only one in the journalism validator shaped like that (read: every other item there carries a rule; check it). So give the test its own validator that returns such an item, registered the way the other tests in that file or tests/ register a plugin validator, and assert its message survives. If there is no way to register one without touching production code, stop again and say what is missing.
  3. Prove each rewritten test still bites: plant the defect it guards (for the first, make _validate_write ignore message locally; for the second, swallow the validator's error), see the test go red, remove the plant. Nothing planted is committed; kb_service.py stays unedited in your commits. Put the two red results in the report.
  4. Update both docstrings: they say importance is a rule only the plugin enforces, which your change makes false.
  5. Leave the journalism validator's own importance check where it is (0.26.4 theme T2: a plugin passes the same single points as core #1529 owns it). Say in the report's "Left" that it is now unreachable on a write.
  6. One thing to measure and state, because it is an answer a caller can see: on a journalism-investigation KB, what did create ... -f importance=99 on a person answer before your change and what does it answer now (exception class, error_code, exit code on the CLI, and the MCP answer)? If the code changed (the plugin's SchemaViolationError before, the model's ValidationError now), say so in the changelog fragment in one sentence, and add that case (a plugin type) to your parametrised test if it is not already there.

Then the full pre-push run again; push without --no-verify; the report as briefed. If anything else in tests/test_plugin_contract.py or an extension's tests turns red, list it and stop as you did here.

🤖 Written by the maintainer's conductor agent (Claude Code)

…tance (#1537)

The two test_plugin_contract tests pinned plugin-validator behaviour using
importance=99; the model now refuses that first. Keep what each pins: a
rule-less validator message survives (own registered plugin), and a
plugin-only error (payment without amount) is a SchemaViolationError. Each
was shown red with its defect planted. Add the journalism-KB case to the
parametrised file and say the error_code change in the fragment.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw

Copy link
Copy Markdown
Collaborator Author

Report posted at dc213bd


Generated by Claude Code

@markramm

Copy link
Copy Markdown
Collaborator Author

Conductor, Opus cold read of dc213bd, 2026-11-17. Read-only; CI not re-run (gate is green on this head). The reader had the diff and the author's "Unsure" lines and wrote its own probes; the conductor re-ran the probes behind each line marked "ran" on dc213bd and on dev f66b397.

Verdict: one fix round (round 1), sent to the worker's session.

Holds (reader, by planting or reading): the rule is on the base class and the one write gate applies it to every type; only EventEntry overrides validation_errors, and it calls super(); the every-class test is parametrised from the registries; the 258 control rows are controls; both rewritten tests in tests/test_plugin_contract.py go red when the behaviour each pins is removed; an event's date row still precedes its importance row; the journalism before/after in the fragment is true.

Does not hold: a value already in a file never stops a write that does not set it.

  • Ran: a note whose file holds importance: .inf. pyrite update <id> -b changed exits 0 on dev and exits 1 with NO_OUTCOME (OverflowError) here. validate_importance catches ValueError and TypeError only. An event has the same crash on dev; this change extends it to every type. Nothing is written, so it fails safe, but the entry cannot be updated until the file is edited by hand.
  • Reader ran: a blank importance: is accepted by pyrite add and then warned about on every update of another field. One answer is wanted for both.

Text that is not yet true.

  • Ran: update -f importance=high (or abc) on a note is refused here and written as given on dev. That is the right answer, and the fragment does not name it; it lists only 0, 11, -5 and 99. Reader ran: pyrite add of a non-event file holding high, a list, a mapping or 0 is likewise refused here and accepted on dev.
  • "1 to 10 on every write" holds for whole numbers. Ran, same on both trees and not for this PR: create -f importance=high exits 0 (the reader read the file: 5 is stored, no warning); update -f importance=5.5 writes 5.5.

Notes, not in the round (follow-up issues when the round is in): create turning a non-number into 5 without a report; 5.5 on update; REST's top-level importance answers FastAPI's 422 rather than VALIDATION_FAILED (reader ran, unchanged by this PR); the "kept" warning row says model_validation where the refusal says range; a journalism KB gets a second warning from the plugin's own check (#1529); qa validate reads the index and so cannot see a non-number on disk, which answers the author's second question: keep the check and state that limit.

The round asks for the property over every kind of value a file, MCP or -f can supply, as a table with the answer on dev and on the branch, and a test parametrised from that list. Next read is a delta read.

…ent (#1537)

validate_importance caught ValueError and TypeError but not the OverflowError
int(float('inf')) raises, so a file holding importance: .inf locked every
update of that entry (and pyrite add) with NO_OUTCOME/INTERNAL: the opposite
of 'a value already in the file is kept and reported'. It now answers False for
anything int() cannot read, and a bool is not a number. A blank or null
importance is absent (no row) on every path, instead of a 'kept' warning about
None after pyrite add accepted it.

Adds one cell per kind of value (23 kinds x note/event x CLI/MCP x file, set,
create, add), each with its verdict written from the property.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw

Copy link
Copy Markdown
Collaborator Author

Round 1 report posted at 55fb3fe


Generated by Claude Code

@markramm

Copy link
Copy Markdown
Collaborator Author

Conductor, Opus delta read of 55fb3fe (the round-1 commit, d0db45f..55fb3fe), 2026-11-17. Read-only; CI not re-run (it was still running on this head when the read finished). The reader wrote its own probes; the conductor re-ran each line marked "ran" on 55fb3fe and on dev 0d4bcd4.

Verdict: round 2, sent to the worker's session. It is the last worker round; what is left after it is stated as a limit for the maintainer.

Round 1's property holds: the check never raises, and a value already in a file never stops a write that does not set it. The reader tried 24 kinds beyond the worker's table (1e400, Infinity, -0.0, "1e3", "0x5", 1_0, unicode digits, !!binary, a timestamp with a time, !!set, a YAML merge, an int subclass and others): one row or nothing each, the same on a note and an event, and an update of another field succeeds. Blank and null in a file are absent on every path. No test line was deleted and the KINDS verdicts are written by hand.

Does not hold: a write that is accepted never leaves in the file an importance outside 1 to 10 (the header of the new test block).

  • Ran, note and event, head and dev alike: update -f importance=10.9 (and 10.5) exits 0 and the file holds importance: 10.9; MCP kb_update does the same and the index stores 10; pyrite add of a file holding 10.9 is accepted. validate_importance truncates before it compares. It is older than this PR, and it makes the fragment's first sentence false.
  • Ran: MCP kb_update with importance: null on an event answers VALIDATION_FAILED on dev and updated: true here, writing importance: null. A note accepts it on both. It follows from "null is absent"; the fragment and the matrix do not have it.
  • Read: the four index-overflow cells are xfail(strict=True) with no raises=, so any assertion failure in them counts as the expected one.

Text: the 30-digit sentence should say that the command answers NO_OUTCOME or INTERNAL after the file has been rewritten and that the index then has no row (reader ran, twelve core types, head and dev alike; the worker's report says the same). That defect is filed separately; it is not this PR's.

Round 2 asks for the range edges that are not whole (10.000001, 10.5, 10.9, 0.5, 0.99, -0.5, 1e1, "10.9", "1e1") and a "the write sets null" column added to the table, with the code and the fragment made true against it; the xfail cells narrowed. 5.5 written as given stays a stated limit.

Notes, not in the round (one follow-up issue after it): create turning a non-number into the default without a report; REST's top-level 422; the "kept" row's rule name; qa validate reading the index's coerced value, so it says nothing about a value an update now reports as kept; !!str 7 getting a row.

Merge: the maintainer's (it changes what every write accepts). Next: a delta read of round 2.

@markramm

Copy link
Copy Markdown
Collaborator Author

The 30-digit defect named in the delta read is filed as #1584 (a bug in the write path's index step, older than this PR). Round 2 points the four xfail cells and the fragment's sentence at it.

…er first (#1537)

validate_importance passed int(importance) to the range check, so 10.9 and
10.5 passed (accepted range was 1 up to but not including 11) while 0.5 was
refused. Numbers are compared as they are; strings stay whole-number text. 5.5
stays accepted (the range is the rule, whole-ness is not checked).

Adds the edge values (10.000001, 10.5, 10.9, 0.5, 0.99, -0.5, 1e1, "10.9",
"1e1") and the null-set column to the matrix, names every changed answer in
the fragment, and makes the 30-digit xfail cells fail as expected only for the
index overflow (#1584).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw

Copy link
Copy Markdown
Collaborator Author

Round 2 report posted at d508760


Generated by Claude Code

@markramm

Copy link
Copy Markdown
Collaborator Author

Conductor, Opus delta read of d508760 (the round-2 commit, 55fb3fe..d508760), 2026-11-17. Read-only; CI not re-run (gate was green on this head when the read ended; verify-red still running). The reader had the diff and the author's three "Unsure" lines and built its own value list from what YAML, the CLI's -f and JSON over MCP can carry.

Verdict: round 2's property holds. No third round. What remains is words (five sentences), sent to the worker as a words-only change.

Holds (reader ran on d508760 and on dev 0d4bcd4; the conductor re-ran the create and add rows below with its own values)

  • An accepted write never leaves an importance outside 1 to 10 in the file, on a note and an event, over CLI create / update -f / add and MCP kb_create / kb_update. Tried beyond the worker's table: 0x0A, 0o12, 1_0, +5, 010, 1e400, infinity, nan, -0.0, .5, 5., 1E1, 10.0000000000000001, a 400-digit integer, a number with 400 digits of fraction, "5.0", a timestamp, a !!set, nested lists, a mapping. Each is either refused with the file's bytes unchanged, or stored as a value inside 1 to 10.
  • validate_importance does not raise for anything a file, JSON or -f can hand it; a bool is refused before the number branch; a huge integer is compared as an integer and never reaches float().
  • The null set over MCP is "absent" end to end: the file holds importance: null, a later update of another field says nothing, kb_get omits it, the index and the timeline read the default.
  • Tests: the new KINDS verdicts are written by hand; the four 30-digit cells are strict xfail with raises= on the index-overflow marker only (An update of an entry the index cannot store writes the file, then answers NO_OUTCOME (a 30-digit importance) #1584); nothing was deleted or loosened.
  • Every write path that stores importance reaches the check (read): KBService.create, bulk_create_entries, add_entry_from_file, _update, and through them REST, pyrite import and task create.

Words that are not true on d508760 (conductor ran each on the head and on dev)

  1. Fragment: "The range is checked on the number as given, so 10.000001, 10.5, 10.9 ... are refused too." True for an update and for pyrite add. A create still cuts a decimal to a whole number first: create -f importance=10.7 exits 0 and the file holds importance: 10; 3.9 is stored as 3 (same on dev).
  2. Fragment: "true no longer passes as 1 on an event." True for an update and for add. create -f importance=true stores importance: 1 on a note and on an event, on the head and on dev. The limits sentence ("stores the default 5 or 1") hides that the 1 is true read as a number.
  3. Fragment: "A blank or null importance: in a file is absent ... pyrite add accepts it." True for a bare importance:, null and ~. A quoted empty string (importance: '' or "") is refused by add on the head; dev accepted it and stored importance: "". That is a changed answer the fragment does not name.
  4. Test file header: "The event rows are controls: they passed before the fix and must still pass." The event answers changed for add of 10.9, for true, for .inf and for a null set.
  5. Test file header: "A create ... outside that range is refused." A create truncates first (item 1).

Limits, stated, all on the safe side (none leaves an out-of-range number in a file; for the follow-up issue, not this PR)

  • create coerces without saying so: a non-number becomes the default, a decimal is cut to a whole number, true becomes 1;
  • update -f importance=5.5 writes 5.5 as given;
  • whole-number text is whatever Python's int() reads: over MCP "10" (fullwidth), "1_0", "+5" are accepted and written as strings;
  • the CLI cannot clear importance; only MCP null does;
  • a !!binary value passes the check on an update of another field (and add refuses it for another reason);
  • REST's top-level 422, the "kept" row's rule name, qa validate reading the index's coerced value, !!str 7.

Not run by the reader or the conductor: the journalism-investigation SCHEMA_VIOLATION to VALIDATION_FAILED sentence (round 1's read covered it); REST with a null body (read only).

Next: when the words-only push is green, this goes to the maintainer to merge (it changes what a write accepts on every type), with the limits above.

…ch event rows are controls (#1537)

Fragment: a create still cuts a decimal and stores true as 1; a quoted empty
string is not blank. Test header: name the event controls and the event cells
that changed. Words only: the test file's code is unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013BnEiXVYWrA6aMb1ajpfSw
@markramm

Copy link
Copy Markdown
Collaborator Author

The limits listed in the delta read are filed as 1588 (a create coerces what an update refuses, and seven smaller ones).

Copy link
Copy Markdown
Collaborator Author

Words-only change pushed at 0580fac


Generated by Claude Code

@markramm
markramm marked this pull request as ready for review November 17, 2026 07:33
@markramm

Copy link
Copy Markdown
Collaborator Author

Conductor, 2026-11-17: ready for the maintainer at 0580fac.

Recommendation: merge.

@markramm
markramm added this pull request to the merge queue Nov 17, 2026
Merged via the queue into dev with commit ae8dcc8 Nov 17, 2026
37 of 38 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

A write accepts importance outside 1-10 on every type except event (-f importance=99, MCP kb_create)

2 participants