v0.27.0

Added

• The documentation site lists every skill, under Skills.
  Sixteen of them across three trees, and which tree a skill lives in decides who can read it and what moving it
  costs. The three tables are generated from the files that already decide the split: plugin.json for what travels
  inside a plugin, manifest.yaml for what travels into a corpus, and the .claude/skills/ directory for what stays
  here. SkillReferenceTests fails a stale table, so the page cannot drift from the manifests the way a hand-written
  one would. Nothing about kac changed.

• kac new and kac update send a corpus the writing-a-report skill. It joins technical-writing and
  writing-a-record in the overlay, under one rule: a writing skill travels where it governs a surface a corpus
  holds. A corpus can adopt reports, so the skill that says how to fill a report's judgement cells travels with it.
  writing-in-the-tool and writing-the-docs describe C# and a documentation site no corpus has, and i-want-to
  routes to this repository's own processes where a corpus reads its own through process-lookup, so all three stay
  behind. reports/_template.md gains the four verdicts as well, for an author who opens the template and loads no
  skill. Before this the words Covered, Covered by its pair, Gap and Out of scope were stated in one file that
  never left this repository, so a corpus adopting reports was told to answer the judgement cells and nowhere told
  with what. manifest.yaml moves to 15, and kac update stamps upstream.template-version.

• kac new and kac update send a corpus the harvest-findings skill, which triages filed findings and drafts the
  record one asks for. raise-finding files an observation as an issue and stops, so nothing moves it afterwards.
  triage reads every finding without a kac:triaged label, sorts each into one of five routes, shows a person the
  table and writes nothing until they agree. draft <issue> takes a kac:route-record finding and opens a pull
  request carrying the record. Both invocations write: to the tracker, and to the records themselves. So the reader is
  the corpus's own maintainer, and the skill lands in the corpus's working tree under .claude/skills/, beside the
  writing skills. No plugin ships it, because a consumer holds a frozen export and not the source. It reads the
  tracker, framework and publishing blocks of .corpus.yaml for the backlog, for where the tool is reported and
  for where the record lives. A framework finding filed on a tracker other than the framework's own is drafted as a
  comment and copied by hand, because an Azure DevOps user has no GitHub account. manifest.yaml moves to 16, and
  kac update stamps upstream.template-version.

• kac validate refuses a target the descriptor names and the tool cannot act on, under a new
  descriptor-target check. publishing-target takes the five values the link rules are written for. tracker.target
  and framework.target take github, azure-devops or none, because a wiki and a documentation site publish
  records and hold no backlog. The message names the key, the value and the list it takes. Only kac new held its
  flags to these lists before, and every one of the keys is written by hand after that, so a misspelling read as a
  corpus that publishes nowhere and files nowhere.

• .corpus.yaml states where work about its records is filed, under a new tracker: key. It takes a target and
  a base, the same pair framework: takes. A corpus that states no block gets the tracker its publishing: block
  implies, so a corpus on GitHub configures nothing: a repository there has an issue list of its own. State the block
  where the backlog and the published form are two places. One Azure DevOps project holds one backlog and many
  repositories, so a repository URL does not address the backlog, and kac export derives the project from it.
  manifest.json states a tracker three times: for the corpus, for the framework, and for every entry in sources.
  Each one gains an id, which is the target and the base normalised, so a caller comparing two of them compares two
  strings and never parses a URL. base and id are both null wherever a block addresses no backlog, so a base is
  never written beside a target that cannot use it. descriptor-version moves to 4, and kac update stamps it. No
  skill reads the key yet.

• .corpus.yaml states where to report a problem with the framework, under a new framework: key. It takes a
  target and a base, the same pair publishing-target and publishing.base take. kac export writes the block
  into manifest.json, beside the id every tracker there gains, so the address travels to whoever installs the
  corpus as a plugin. Its base is written the way every tracker's is, so an Azure DevOps base is the project holding
  the backlog. Before this, the only address an export carried was the corpus's own publishing.base.
  upstream.url was never one: it says where the template was copied from, and that is often a folder. kac new
  writes the block, taking the base from --from where that names a repository and from the framework's own
  repository where it names a folder. descriptor-version moves to 3, and kac update stamps it. No skill reads the
  key yet.

• A fix takes status: draft, and a draft states no verification. verified is required of every other
  status, so a session can write a fix from an observation nobody has checked and kac validate passes. The type's
  export shape moves to fixes@2, because verified arrives as null on a draft. A corpus listing draft under
  export.exclude: in .corpus.yaml withholds a draft, which is how an unchecked resolution stays out of
  fix-lookup.

• fix-lookup, the skill that says whether a problem has already been solved here. It searches
  symptom-keywords, which a fix over-fills with error text and the words somebody arrives with, then reports the
  Symptom, Cause and Resolution the corpus settled. It states the record's derived trust on every answer, so a
  caller can tell a resolution a person checked from one an agent ran. A fix declares no part, so the skill searches
  corpus/fixes/ and the record is the unit. It ships in every corpus's plugin.json and leaves the bundle wherever
  the export carries no fix. Take it with kac update --from <template>.

• raise-finding searches the fixes before it files anything about a problem. Seven sessions meeting the same
  problem should not open seven issues. Where the plugin has no fix-lookup, the corpus declined the fixes type and
  the finding is the only route. Take it with kac update --from <template>.

Changed

• A verification taken before generated.at reaches no trust tier. kac export derived trust from verified
  alone, so a report somebody read in March still shipped as human-reviewed after an agent rewrote its verdicts in
  September. Authorship now passes to whoever answers those cells, which moves generated.at past every reading of
  the words before them, so the exporter leaves an older entry out. A moment that will not parse still counts, because
  timestamp-format already reports it against the record.

• A report's generated says who wrote the content, and authorship passes to whoever edits it. kac report wrote
  itself into generated.by and left it there, so a report an agent finished credited the tool with the agent's
  verdicts. by now names whoever wrote the content a reader meets, which the Open Knowledge Format defines it as and
  illustrates with a person. Two keys survive the handover: report states the report the run used, as coverage, so
  a record says which kac report name regenerates it, and tool keeps the version that wrote the mechanical half.
  Both are optional, and a report nobody produced with the tool states neither. generated-by-a-producer is renamed
  generated-by-a-known-actor and admits all three actor forms, so human:alex.doe is now a legal author.

• A report states no verification until somebody reads it. verified was required with at least one entry, so an
  agent finishing a report had to name a verifier to get past kac validate, and the two worked corpora each named an
  agent that does not exist. The field now follows fixes: a draft states none, and every other status states one.
  A report with no entry is the Open Knowledge Format's unverified tier, which kac export already ships as trust.

• An accepted ADR is edited in place, and only a changed decision needs a superseding ADR.
  immutable-after-accepted allowed a typo fix, a link correction and a status transition, and nothing else. That
  list left out an edit changing no decision. A sentence that no longer matched the decision the ADR already stated
  read as forbidden. The rule now asks whether the decision changed, and adrs.md says to name the edit in the commit
  message. immutable-after-published takes the same shape for a postmortem, where a new understanding is a new
  postmortem. Both are still declared and do not run, because telling a changed decision from a correction needs git
  history. The Decided tier note in _tiers.yaml drops "never rewritten" for the same reason, so a corpus's
  knowledge-as-code/taxonomy.md changes when you regenerate it. kac update --from <template> takes all three, and
  kac generate rewrites the blocks under them. adrs.md and postmortems.md seed a corpus, so the Immutability
  paragraph on each stays that corpus's own to reword.

• kac export reports every reason it refuses in one run. A type the corpus has not adopted, an export-exclude
  key it cannot act on, a consumed corpus nothing is restored for, a consumed corpus at another export format and two
  corpora disagreeing about a type are each one line, and all of them print before the run stops. A shape or fidelity
  line now ends with what to do about it. Before, the first of them stopped the run on its own.

• A finding raise-finding files is the observation, and proposes no record. Its kac-finding block drops id
  and expires, which were a proposed discovery's own fields, and gains looks-like. That key takes the type the
  observation resembles, framework where what was noticed is the tool, the schema or a skill, or none. Whoever
  triages the issue gets the hint and keeps the decision. corpus, source, confidence, provenance,
  applies-to and tags are unchanged, and so are the body's three headings. Take it with
  kac update --from <template>.

Removed

• The discoveries type and the observed tier. A corpus no longer keeps an unverified observation. One goes
  into whatever tracker that corpus already uses, and what the corpus keeps is the answer somebody settled and
  verified. kac new writes one type fewer, and kac validate counts one template fewer. fixes and standards
  drop promoted-from, so a record that still has that key fails unknown-key; sources states where the content
  came from instead. A schema-shape message naming the tiers now offers four. Take it with
  kac update --from <template>, which deletes discoveries.md, the folder and the schema file.

Fixed

• kac export publishes a grandparent's record files down a chain three corpora deep. A consumer read only the
  record files sitting directly in an imported type's directory. The records its producer had inherited were dropped,
  and their part lines reached the next corpus naming files that never arrived. kac now reads the folders a producer
  filed those records in, and files each record under the corpus that wrote it. A corpus consuming both a producer and
  that producer's own producer meets one record twice, and writes and counts it once. sources already listed the
  grandparent, and still does.

• kac validate resolves a citation into a corpus reached through another. gp:pol-OLD was reported as a
  shortcode this corpus consumes nothing under. The reader behind validate skipped the folders an export files an
  inherited record in, and filed what it did read under the corpus it arrived through. A record is now found by the
  shortcode of the corpus that wrote it, whether this corpus declared that corpus in consumes: or not.
  eng:pol-OLD correspondingly stops resolving, which is what ref-resolves already says about a record eng does not
  have. While a declared import is unrestored, a shortcode nothing here knows is left to import-restored instead of
  drawing a second finding telling the reader to declare it.

• kac report coverage credits a grandparent's standard against the clause it implements. A record file keeps the
  ids its own corpus wrote, and the edge was scoped to the corpus the record arrived through. The clause read as a gap
  and the standard covered nothing, because the clause lines are scoped to the corpus that wrote them.