v0.26.0

Added

• kac validate checks that a quoted clause still says what it is quoted as saying. A control quotes the clause it
  verifies, and nothing until now compared the two. clause-quoted-faithfully takes every double-quoted span on a line
  that also cites a clause, and reports it as an error where the cited clause no longer contains those words.
  Whitespace is collapsed on both sides, so a quotation wrapped across two lines is read whole. A quoted span on a line
  citing nothing is left alone, and so is a citation into a corpus you consume: an export sends a record's ids and
  fields, not its wording. .schema/controls.yaml declares the rule, so take it with
  kac update --from <template>.

• A fix travels in an export. .schema/fixes.yaml declares an export: block at shape 1, so kac export writes
  one JSON per fix. The record carries symptom-keywords, which is what a lookup searches on. It carries Symptom,
  Cause, Resolution and Why it happens whole, because a resolution read without its cause is half an answer. It carries
  verified, and the record's trust is derived from that list. Three things stay behind: How we found it, which
  names commands a consumer cannot run, promoted-from, which names a discovery that travels nowhere, and owner.
  Take the schema with kac update --from <template>, and adopt the type with kac update --add-type fixes.

• kac report --out <path> writes the report to a file. Without it the report still goes to standard output, so
  a caller piping one loses nothing. With it kac writes the file after it has read the corpus, which is what keeps
  a run off the console encoding and out of the way of a shell holding the same path open. A path a file already
  occupies is refused and nothing is written, because a finished report holds verdicts somebody wrote.

• Every record can say where its content came from. .schema/_universal.yaml declares sources, an optional list
  whose entries carry a required resource. A resource names something a reader can follow, such as a ticket URL, or
  the population the content was drawn from. sources is what the Open Knowledge
  Format calls the same list, and
  resource is its one required key. No type carries the universal field into an export, so a record a consumer holds
  stands up without the ticket behind it. reports keeps its own sources, which requires the field and adds the
  version each corpus was at. Take the field with kac update --from <template>.

Changed

• The prose in .schema/ is rewritten to the writing rules. Every description:, notes:, message: and comment
  in the schema was rewritten against them. A record author reads a shorter field description in the ## Metadata
  table, and a plainer sentence from kac checks and from a rule that fails. No check id, severity, expr:, pattern,
  threshold or export shape changed. Reasoning that had grown into a notes: now sits on the design site, under
  Checks,
  Shaping a type and
  Reports, and the notes: cites it. Run
  kac generate after taking the schema with kac update --from <template>.

• The ## Metadata table says what a field is, where it used to describe the schema. A field declaring only
  notes: fell back to them for its table cell, so maintainer commentary was published to whoever writes a record.
  Every field now declares a description:. An ADR's superseded-by reads "The ADR that replaces this one." where it
  read "CI reconciles both directions, so a one-sided supersession fails the build." Run kac generate after taking
  the schema with kac update --from <template>.

• Every check message opens lower case. Twenty-three rule messages in .schema/ opened with a capital, where
  kac prints a message mid-line after the check id. Several also ran to four or five sentences. Each now opens lower
  case and states what is wrong, then what to write instead.

• .schema/ states the reasoning local to a field and cites the site for the rest. A notes: had grown into a
  multi-paragraph design argument in forty-six places, and much of it repeated a documentation page. The prose in
  .schema/ is a third shorter. The per-type export choices and the framework-register rules now sit at
  https://paul80nd.github.io/knowledge-as-code/design/shaping-a-type/, which each type file cites.

• kac report frameworks says more beside each framework's table. Every reference row carries a Citations count,
  so a reference one clause cites reads as 1 without counting the cell next to it. Each framework's section opens on
  the standing the register files it under, linked to the register entry that placed it, which is the line a reader
  would otherwise scroll back to the totals table for.

• Each report writes its own ## Limits. Both printed one wording, written for a reading of clause coverage.
  frameworks now says that an Alignment cell stays in the corpus that wrote it, so it counts the citations written
  here, and that a citation records the naming rather than a clause meeting what it cites.

• The five lookup skills drop their search procedure. kac new, kac update and kac bundle send skills that
  name no search tool and no search flags. A trial ran three variants of policy-lookup over five questions: the
  skill as it shipped, one without the tool name, and one without the search section at all. Every variant found and
  cited every governing clause. Each run of the shipped skill spent tool calls hunting a Grep tool the session did
  not hold. What stays is what an agent cannot work out for itself: the file map, the field table, and the warning
  that a field name like status matches every line of the file.

• glossary-lookup, policy-lookup and standards-lookup answer the near miss. Each carries a section for a
  subject the corpus has not written down that sits beside one it has. "Password rotation" meets a policy about
  rotating secrets, and the skill now says to name the nearest clause as the nearest one and leave the reading to
  its owner.

• confirmed is now verified, it takes any actor, and the export carries the trust tier derived from it. The
  field is renamed on fixes and reports, which is what the Open Knowledge
  Format calls the same list. It no
  longer refuses an agent: a session that reproduced a symptom and ran the resolution has checked something real, and
  verified-by-a-known-actor admits it, named with its version the way the tool names itself. That rule still refuses
  a role:, because a post cannot read an answer. Who is in the list decides the record's tier, which each record file
  now ships as trust: an empty list is unverified, agents alone are machine-confirmed, and one human: actor is
  human-reviewed. A type whose export does not name verified carries trust as null. One actor is still
  refused, and no-self-verification is the new rule and reports as self-verification: a report may not be verified
  by the producer its generated.by names. A fix declares raiser-does-not-verify and nothing runs it, because
  nothing on a fix names who raised it. kac report writes verified: [] where it wrote confirmed: []. A corpus
  that adopted either type renames the key in every record and in its _template.md, and takes the new schema with
  kac update --from <template>. The reports type's shapeVersion moves to 2, so a consumer reading records of
  that type reads the new key.

• The faq type is now fix, and its Fix section is now Resolution. A record lands in fixes/ as
  fix-0001, the page beside it is fixes.md, and kac validate holds the record to Symptom, Cause and
  Resolution. The type and its third section no longer share a word. A corpus that adopted faqs renames the
  folder and the page, changes each record's type:, id:, identity line and Fix heading, then writes fixes
  over faqs in types: and deletes .schema/faqs.yaml by hand. kac update --drop-type faqs refuses that
  step, because the template no longer declares the name. kac update --from <template> then takes the new
  schema file. The type's page and its _template.md are seeds, so a corpus keeps the copies it has, and
  validate names every line of them still saying FAQ.

Fixed

• kac prints UTF-8 on Windows. Standard output took whatever code page the machine was installed with, so a
  clause citing §9 reached the reader as a replacement character while the same text in the record was intact.
  Every command writes through the same stream. kac report is where it showed, because a report quotes citation text
  back.

• kac report writes frontmatter a parser accepts. owner: human: is not valid YAML, so a generated report met
  frontmatter-parses over the whole document rather than a message naming what to fill in. id, owner and
  verified now arrive empty, and kac validate reports required-field against each one.

• kac report calls a fresh report a draft. The schema requires status and no run wrote it, so every generated
  report failed kac validate until somebody added the field by hand. The frontmatter now carries status: draft.

• id-matches-filename names the two things that disagree. It printed the whole id where it meant the id's own
  slug, so a record filed as reports/rpt-clause-coverage.md was told that rpt-clause-coverage does not match
  rpt-clause-coverage. It now reads id 'rpt-clause-coverage' carries slug 'clause-coverage', and the filename carries 'rpt-clause-coverage'. The number and the mnemonic branches take the same wording.

• An unhandled fault goes to stderr. Spectre's own handler wrote one to stdout, so kac report coverage > out.md
  put the message inside the report and left the console silent. Every verb's own refusal already went to stderr, and
  this joins them.

• The report page taught a filename that does not validate. Its example wrote reports/rpt-clause-coverage.md,
  and a record whose filename repeats the id prefix fails id-matches-filename. The filename carries the question the
  report answers, and the prefix belongs to the id.

• sections is described as the object it is. policy-lookup and standards-lookup told a reader to read two
  or three things from sections without saying it is keyed by heading, and a reader parsing it as a list gets
  nothing back.