An output policy for the three commands, and @cond as a true special form

A snapshot of the development tree.  The substantial changes since the last one:

COMMAND OUTPUT POLICY.  The three commands display text in exactly three cases,
and each owns a stream: LOGGING under "-v" greater than 0 and an ERROR before
termination go to STDERR; OUTPUT THE USER ASKED FOR goes to STDOUT.  For ktext
that output is a document, so "ktext doc.kt -d | ..." is now safe -- logging
used to share the stream and land inside the document.  A bare command prints
its usage and succeeds rather than failing.  Colour is emitted only to a
terminal, per stream, and NO_COLOR is honoured.

"-v 1" reports every decision whose outcome you could not have read off your own
input: the klammerset that was loaded and from which file, a font's directory, a
":files" name's file, how "-o" was expanded.  Higher levels are the trace.

The commands no longer warn and continue: an anomaly is an error, described with
its location.  Two exceptions remain, each for a stated reason -- a condition
that is expected and temporary by design, and a judgment that is a heuristic
rather than exact.

@cond IS NOW A TRUE SPECIAL FORM, resolved at APPLICATION time rather than when
the file is read.  Two consequences for a writer:

  * a state variable reaches the predicate.  "@@@state Flag :value true @@@
    @cond *Flag* | T | F @" renders "T"; it used to see the literal "*Flag*" and
    silently take the false branch.  The document now behaves like a klammer
    body, whose arguments are bound before its conditionals are decided.
  * nothing in a discarded branch happens -- it is not read, not evaluated, not
    expanded.  An @eval in the branch not taken used to run anyway.

Its predicate relation is total and strict: true, True, 1; false, False, 0, and
empty; anything else is an error at the @cond rather than silently false.

@eval REACHING OUTSIDE.  ":shell" and ":haskell" now keep the command's standard
error out of the document (it appears under "-v 1") and treat a nonzero exit as
an error naming what the command reported.  A command that exits nonzero on
purpose -- "grep" finding no match -- says so with "|| true".

KLAMMER SETS.  Several combine: "--klammersets a b c" loads all three in the
order given, sharing one namespace, with the definition modes deciding
collisions.  "none" means none and may not be combined with other symbols.  A
klammerset with symbol X is declared in a file X/X.k, which is what lets two
sets require the same third set without loading it twice.

TESTS.  Four new suites: the kdiag command's interface, the @eval primitive's
contract with the outside world, and verbosity at both tiers.  Three suites
that could not run on macOS at all now do.

Assembled from dev commit 6c8ee6c22fca.

mac/machine.h

@@ -46,7 +46,14 @@ public:
         return *this;
     }
     
-    void process_cond_katoms(std::vector<Katom>& katoms);
+    // @cond is resolved at APPLICATION time, not read time (Andy, 2026-08-15,
+    // deciding notes/Klammertext_improvements.md §4.2).  mark_cond_content()
+    // runs during process_katoms and makes every branch inert;
+    // resolve_cond_katoms() runs inside the apply fold, selects a branch, and
+    // processes only that one.  The document then behaves like a klammer body:
+    // its state variables are bound before its conditionals are decided.
+    void mark_cond_content(std::vector<Katom>& katoms);
+    int resolve_cond_katoms(std::vector<Katom>& katoms, const std::string& target);
     void process_eval_katoms(std::vector<Katom>& katoms);
     void mark_literal_klammer_content(std::vector<Katom>& katoms);
     void escape_target_characters(const Target& target, std::vector<Katom>& katoms);
@@ -73,8 +80,19 @@ public:
     void expand_constant_klammers(katom_list& katoms, const Katom& op, const Katom& cl);
     void add_definition(katom_list& katoms, const Katom& op, const Katom& cl);
     void load_klammerset_files(const Klammerset& klammerset, katom_iter insert_at);
-    void extract_machine_definitions();
-    void extract_klammer_definitions();
+    // `tolerant` is for kdiag ONLY.  It dissects the structure and typing of
+    // the katom list, and allows modes of processing that would be errors in
+    // ktext: run one definition tier without the other and a definition may
+    // be unregisterable (a klammer names a target that "--system" would have
+    // registered).  Tolerant then SKIPS that definition instead of throwing,
+    // leaving its katoms unconsumed and therefore visible -- which is the
+    // report.  ktext must keep throwing: there, a document naming an
+    // undefined target is a genuine error, and skipping it silently would
+    // render a wrong document.
+    void add_machine_definition(const std::string& name, katom_iter begin,
+                                katom_iter end, bool& rescan);
+    void extract_machine_definitions(bool tolerant = false);
+    void extract_klammer_definitions(bool tolerant = false);
     void extract_klammer_definitions(katom_list katoms);
     void update_state(const std::map<std::string, std::string>& arg_map);