v0.8.7: tool capability metadata, in-process engine, Qt app, Android engine

The engine can be embedded now instead of only driven from a terminal: the
same objects link into a Qt front end (app/) that owns a cst_agent_t inside
its own process -- no port, no token, no second process -- and that front end
now runs on the desktop and, engine-side, on the phone.

Capability metadata (include/cst_tools.h, src/tools/registry.c):
- cst_tool_def_t gains perm_name, platforms and available (a probe that
  returns a reason), so a permission is addressable by name and a tool can
  say why it cannot run here.
- cst_platform_name(), cst_tool_platform_ok(), cst_tool_available(),
  cst_tool_meta_reload(), cst_tool_perm_name() and CST_PLAT_DESKTOP[].
- cst_tool_register() may take over a built-in name that is not runnable on
  this platform, so a front end replaces it with its own implementation.
- the registry entries carry their class (delete_file -> "delete"), the
  desktop clipboard tools carry a clipboard probe; find/active/run gate on it.
- /api/settings.tools[] exposes perm_name, platforms, available, why and the
  declared parameters.

Engine as a library (Makefile, CMakeLists.txt):
- libcstcore.a from the CORE_OBJ set, and a CMake cstcore target shared by
  the CLI and by app/ (-DCST_BUILD_APP=ON): the engine is compiled once.
- Android branch for the vendored sashidown: a per-ABI archive built with the
  NDK's aarch64-linux-android24-clang wrapper, because CMake's compiler is
  plain clang and keeps --target/--sysroot in its own variables.

Qt front end (app/, new):
- AgentCore wraps one cst_agent_t: turns run on a worker thread, every
  cst_agent_hooks_t callback becomes a Qt signal, and the two hooks that need
  an answer (on_permission, on_ask_user) block the worker until the GUI
  replies; mode, approval and plan mode go through the engine's config.
- ToolProvider hands the front end's tools to the engine (owner "app:*"); the
  Linux one is notification_send with a probe for notify-send/D-Bus.
- Main.qml: transcript, tool blocks, consent dialog (Deny/Once/Always ->
  CST_PERM_*), ask_user, mode switch, Esc to cancel; --selftest stays
  headless and runs the embedding checks without QML.

Android (scripts/, docs/android.md, new):
- scripts/build_third_party_android.sh builds static mbedTLS + libcurl for an
  ABI (CA path /system/etc/security/cacerts); build_android.sh builds
  cst-agent, libcstcore.a and the test binaries for the phone, can push them
  and run the whole suite there.
- sandbox_exec.c keeps the plain exec path on Android: the seccomp supervisor
  compiled in and the probe reported "seccomp", but writes outside the
  workspace were not denied on the device -- claiming a sandbox that does not
  hold is worse than reporting none.
- tests/test_diff.c compares layouts only against real GNU diffutils: toybox's
  diff prints the same hunk header with its own hunk/context rules.

Tests: test_tool_meta (metadata, platform gate, probe reasons, takeover of a
built-in name) and test_embed (in-process embedding contract) are new; the
existing registry/llm_body assertions now follow availability. 38 test
binaries pass on the host, 36/36 on arm64-v8a Android 16, cst-app-selftest
passes in both the standalone app/ build and the repo build.

Version 0.8.7.

docs/android.md

@@ -0,0 +1,73 @@
+# CST-agent on Android
+
+The engine runs on the phone as a plain bionic binary -- no Termux, no proot,
+no second process for the UI to talk to. It is the same C core the CLI, the
+TUI and the WebUI use, cross-compiled with the NDK; on the phone the Qt front
+end (app/) will link `libcstcore.a` in-process and register its own platform
+tools under the owner `app:android`.
+
+Two scripts cover the engine side:
+
+| script | what it does |
+| --- | --- |
+| `scripts/build_third_party_android.sh ABI [all\|mbedtls\|curl]` | static mbedTLS + libcurl into `third_party/prefix-android-ABI` |
+| `scripts/build_android.sh [ABI] [--push] [--run] [--run-tests]` | `libcstcore.a`, `cst-agent`, the test binaries; optional push and on-device run |
+
+## Toolchain
+
+NixOS: nixpkgs carries the NDK (the Android SDK license makes it unfree, hence
+the flag; the packaged NDK has a patched interpreter, so its clang runs here):
+
+```sh
+export ANDROID_NDK_HOME=$(NIXPKGS_ALLOW_UNFREE=1 nix build --impure --no-link \
+  --print-out-paths 'nixpkgs#androidenv.androidPkgs.ndk-bundle')/libexec/android-sdk/ndk-bundle
+```
+
+`adb` comes from `nix-shell -p android-tools`; the builds need cmake, ninja and
+curl. End to end:
+
+```sh
+nix-shell -p cmake ninja curl android-tools --run '
+  JOBS=16 ./scripts/build_third_party_android.sh arm64-v8a all'
+nix-shell -p cmake ninja curl android-tools --run '
+  JOBS=16 ./scripts/build_android.sh arm64-v8a --push --run'
+```
+
+`--run` finishes with the two smoke checks on the device (`cst-agent
+--version` and `tests/test_embed`, the in-process embedding contract);
+`--run-tests` builds the whole `tests/` suite, pushes it and runs every binary
+on the phone, printing a pass/fail line per test.
+
+## What is Android-specific
+
+* **API level 24** (`API_LEVEL=24`): bionic provides threads, `exec` and
+  `/system/etc/security/cacerts`, which is where libcurl is pointed
+  (`CURL_CA_PATH`). Bump the level if a newer syscall or CA layout is needed.
+* **No TUI, no WebUI**: `-DCST_BUILD_TUI=OFF -DCST_BUILD_WEBUI=OFF` -- there is
+  no ncurses on Android, and the phone front end talks to the engine in-process
+  instead of over HTTP. `src/webui_stub.c` compiles in place of the server.
+* **Sandbox**: `src/sandbox_exec.c` only enables the seccomp/Landlock paths
+  under `defined(__linux__) && !defined(__ANDROID__)`, so the phone build gets
+  the plain exec path -- the same rule the Termux build follows.
+  The seccomp supervisor used to compile in and the probe reported "seccomp",
+  but on the device a write outside the workspace was not denied
+  (`tests/test_sandbox.c:308`), so the phone build now reports no sandbox
+  instead of one that does not hold.
+* **sashidown** is built per ABI (`vendor/sashidown/libsashidown-<abi>.a`) with
+  the NDK's `aarch64-linux-android24-clang` wrapper: CMake's compiler is plain
+  clang and keeps `--target`/`--sysroot` in its own variables, which the
+  vendored makefile cannot see. The host archive stays host-built.
+* **Static libcurl** needs `-L$PREFIX/lib` on the link line, because curl's own
+  CMake config lists its mbedTLS dependencies as `-l` flags rather than paths.
+
+## Status
+
+* arm64-v8a, Android 16 (NX789J): `cst-agent` runs, `tests/test_embed` passes.
+* The whole suite runs on the device (`scripts/build_android.sh arm64-v8a
+  --run-tests`): 36/36 after the diff test learned to tell toybox's `diff` from
+  GNU diffutils.
+* Still to come: the Qt front end packaged as an APK. nixpkgs has no Qt for
+  Android build, so that needs a Qt host kit plus the `android_arm64_v8a` kit
+  (qt.io or aqtinstall), a JDK and the Android SDK platform/build-tools;
+  `app/src/platform/android/` (JNI tools, owner `app:android`) and the Gradle
+  project under `app/android/` do not exist yet.