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.

tst/target_list_test.sh

@@ -22,7 +22,7 @@
 #                            "*arg*" variables, and the closing delimiters
 # Case 14 guards the second: a comma next to an application is writer text.
 #
-# These are engine tests, so they use -k none and define their own targets
+# These are engine tests, so they use --klammersets none and define their own targets
 # inline: a target is a Machine construct (@@@target), not owned by any
 # klammer set.
 #
@@ -54,7 +54,7 @@ trim() { awk '{ sub(/[ \t\r]+$/, "") } { line[NR]=$0 } END { f=1; while (f<=NR &
 check_eq() {
     local name="$1" target="$2" expected="$3" src="$4"
     local out status err
-    out=$("$KTEXT" -k none -s "$TARGETS$src" -t "$target" -d 2>"$ERR"); status=$?
+    out=$("$KTEXT" --klammersets none -s "$TARGETS$src" -t "$target" -d 2>"$ERR"); status=$?
     err=$(cat "$ERR")
     out=$(printf '%s' "$out" | trim)
     if [ $status -ne 0 ]; then
@@ -73,18 +73,25 @@ check_eq() {
     fi
 }
 
-# check_warn NAME TARGET EXPECTED SRC — exit 0, stdout==EXPECTED, AND a warning.
+# check_warn NAME TARGET EXPECTED SRC — exit 0, stdout==EXPECTED, the override
+# SILENT at the default verbosity and REPORTED at "-v 1" (2026-08-15; see
+# tst/deftype_test.sh's check_warn for why it is no longer a warning).
 check_warn() {
     local name="$1" target="$2" expected="$3" src="$4"
     local out status err
-    out=$("$KTEXT" -k none -s "$TARGETS$src" -t "$target" -d 2>"$ERR"); status=$?
-    err=$(cat "$ERR")
+    out=$("$KTEXT" --klammersets none -s "$TARGETS$src" -t "$target" -d 2>"$ERR"); status=$?
     out=$(printf '%s' "$out" | trim)
     if [ $status -ne 0 ]; then
         echo "${red}FAIL${reset} $name — ktext exited $status"; FAIL=$((FAIL+1)); return
     fi
-    if ! printf '%s' "$err" | grep -qiF "warning"; then
-        echo "${red}FAIL${reset} $name — expected a warning, got none"; FAIL=$((FAIL+1)); return
+    if [ -s "$ERR" ]; then
+        echo "${red}FAIL${reset} $name — the default run was not silent: $(head -1 "$ERR")"
+        FAIL=$((FAIL+1)); return
+    fi
+    "$KTEXT" --klammersets none -s "$TARGETS$src" -t "$target" -d -v 1 >/dev/null 2>"$ERR"
+    err=$(cat "$ERR")
+    if ! printf '%s' "$err" | grep -qiF "overridden"; then
+        echo "${red}FAIL${reset} $name — no override reported at -v 1"; FAIL=$((FAIL+1)); return
     fi
     if [ "$out" = "$expected" ]; then
         echo "${green}PASS${reset} $name"; PASS=$((PASS+1))
@@ -98,7 +105,7 @@ check_warn() {
 check_error() {
     local name="$1" target="$2" pattern="$3" src="$4"
     local out status
-    out=$("$KTEXT" -k none -s "$TARGETS$src" -t "$target" -d 2>&1); status=$?
+    out=$("$KTEXT" --klammersets none -s "$TARGETS$src" -t "$target" -d 2>&1); status=$?
     if [ $status -eq 0 ]; then
         echo "${red}FAIL${reset} $name — expected an error but ktext succeeded"; FAIL=$((FAIL+1)); return
     fi