v0.5.0

Probe queries can be answered without classifying the whole ontology first: howl ask,
howl_run_answer and Reasoner::answer classify only the queried classes' module. On Core (BFO and
CCO merged), 30 queries take about 1 s, where the two-run mode takes 14 s. HOWL is now generated
with slop 0.5.1, which renames the enum and struct types in howl.h, so C callers must update those
names (see Changed). The existing Rust API and the report grammar are unchanged.

Added

• Answering probe queries without classifying first (SPEC §8.4). The answer run is the probe
  run alone, with no main run: usually one classification, of the queries' module, instead of two
  of the whole input. It is additive: nothing existing changes.
  • It classifies the queries' module first. This is the syntactic ⊥-locality module (Cuenca
    Grau, Horrocks, Kazakov and Sattler, JAIR 2008), which entails exactly what the ontology entails
    about the queried classes whenever HOWL can read every axiom in it. It is usually far smaller,
    and auto picks a profile for the module alone.
  • It falls back to the whole input when the module's run is incomplete: an omission inside
    the module, a round cap, or the clause budget. That makes two classifications in that case.
  • It gives every yes and no the two-run mode gives. It also answers where an omission
    outside the module made that mode say unknown.
  • C API: howl_run_answer(input, options), read with the existing howl_run_probe_*
    accessors. The run has no report, its verdict is inconclusive, and howl_run_profile names
    the profile that answered.
  • Rust: Reasoner::answer and answer_cancellable, returning Answers (the profile,
    probes, inconsistent, omissions and lines()).
  • CLI: howl ask FILE [--probe F]... --ask-unsat C | --ask-sub A B ... prints profile P and
    the probe lines. It exits 0 when it answered, whatever the answers; 2 if cancelled; 3 on an
    error.

Changed

• The Rust crate compiles the engine with the release CLI's flags: -O3 and 65,536 intern
  buckets, where it used -O2 and 4,096. The crate pins these whatever the host's Cargo profile.
  It is 0–3% faster on the corpus, and every report is identical.
• howl_run_ok means the run has a result, now including an answer run's answers. It is
  unchanged for every howl_run_classify run: it is false exactly when the run faulted.
• The macOS release binary and library are built with Apple clang, where they used Homebrew
  gcc-14 (a choice inherited from GROWL's CI, never measured).
  • On the corpus, a clang build of the engine runs 14–21% faster than a gcc build (gcc-16 locally,
    release flags), with identical reports.
  • CI's macOS job builds and tests with clang too.
  • Linux and Windows are unchanged (gcc, MinGW gcc).
• Generated with slop 0.5.1 and slop-rdf 0.6.0. The crate depends on slop-std-sys 0.5 and
  slop-rdf-sys 0.6.
  • Breaking for C callers: slop 0.5 adds the package to generated C names (slop #360), so
    the enum and struct types in howl.h are renamed. types_Verdict_*, types_Profile_*,
    types_Termination*, probe_QueryKind_* and probe_ProbeAnswer_* gain a howl_ prefix
    (howl_types_Verdict_verdict_coherent), and rdf_TermKind_* becomes
    slop_rdf_rdf_TermKind_*. Values and layouts are unchanged, as are the howl_* functions and
    the Rust API.
  • The crate's -sys dependencies are caret ranges again, where they were pinned exactly. Its
    build no longer compares the runtime header byte for byte. Every generated header checks
    SLOP_RUNTIME_ABI instead, so C generated for another runtime ABI fails to compile, and a
    header that differs only in comments builds.

Fixed

• Turtle: a dot inside a prefix name or blank-node label (slop-rdf #13). @prefix j.0:, as
  rdflib writes it, failed to parse. _:b.1 was cut to _:b and the leftover read as the next
  statement's subject, a silently wrong triple. Both now read as Turtle defines them. A literal in
  subject position is now a parse error (exit 3); it used to be read as a triple.
• sriq: a DisjointUnion headed by owl:Thing or owl:Nothing no longer faults. The head
  reached the clause boundary as a plain class name, which has no id for a built-in, so a valid
  ontology was refused as an input error. It now lowers to ⊤ or ⊥, as decode reads those names
  everywhere else: DisjointUnion(owl:Thing, P, Q) with P and Q empty is inconsistent, and
  DisjointUnion(owl:Nothing, P, Q) makes P and Q unsatisfiable.