feat: emit exiting{reason:"requested"} on clean shutdown (Aegis Engine Protocol v1)

Aegis-AI's daemon (aegis-daemon, W7 Rust rewrite) needs to tell a clean,
planned shutdown apart from a real crash. Today SwiftLM's SIGTERM/SIGINT
handlers print plain text and exit(0) with no machine-readable signal at
all.

Adds a small shared emitEvent(_:) helper (used by both the existing ready
event and this new one, replacing ready's inline JSONSerialization call)
and emits {"event":"exiting","reason":"requested"} on both signal handlers
before exiting. Consumers should ignore unrecognized future reason values
rather than error on them.

This is Phase 1 of a larger plan (see Aegis-AI's daemon/spec/engine-protocol.md
§3/§4) — self-reporting a SPECIFIC failure reason on a real crash (OOM,
model load failure, etc.) is separate, larger follow-up work, since none
of those paths have any error handling to build on today.

Verified: swift build --target SwiftLM (debug) and swift build -c release
--product SwiftLM both green. Smoke-tested against a real Aegis-AI daemon
build in an isolated sandbox: reached ready normally, and a real SIGTERM
via the daemon's stop endpoint exited the process cleanly with the new
event observed, without the daemon misclassifying it as a crash.

Author: solderzzc

Sources/SwiftLM/Server.swift

@@ -189,6 +189,21 @@ final class ProgressTracker {
     }
 }
 
+/// Emit one machine-readable JSON-lines event on stdout for the Aegis-AI
+/// daemon to consume (`docs/AEGIS_INTEGRATION.md`, and the daemon's own
+/// `daemon/spec/engine-protocol.md`). Shared by the `ready` event and the
+/// `exiting` event so the JSON-encode-and-flush boilerplate isn't
+/// duplicated at each call site — this is deliberately the SAME manual
+/// `JSONSerialization` shape the pre-existing `ready` event already used,
+/// not a new encoding convention.
+func emitEvent(_ payload: [String: Any]) {
+    if let data = try? JSONSerialization.data(withJSONObject: payload),
+       let json = String(data: data, encoding: .utf8) {
+        print(json)
+        fflush(stdout)
+    }
+}
+
 @main
 struct MLXServer: AsyncParsableCommand {
     static let configuration = CommandConfiguration(
@@ -1026,24 +1041,29 @@ struct MLXServer: AsyncParsableCommand {
             }
             readyEvent["partition"] = info
         }
-        if let data = try? JSONSerialization.data(withJSONObject: readyEvent),
-           let json = String(data: data, encoding: .utf8) {
-            print(json)
-            fflush(stdout)
-        }
+        emitEvent(readyEvent)
 
         // ── Graceful shutdown on SIGTERM/SIGINT ──
+        // Engine Protocol v1 (`daemon/spec/engine-protocol.md` §3, TD-7):
+        // emit `exiting{reason:"requested"}` before exiting so the daemon
+        // can tell a planned, no-error stop apart from a real failure —
+        // `requested` has no `ExitClassification` equivalent on the daemon
+        // side (a daemon-requested stop never reaches that classifier at
+        // all), it exists purely for the daemon to positively confirm this
+        // was a clean shutdown, not infer it from absence of other signals.
         let shutdownSource = DispatchSource.makeSignalSource(signal: SIGTERM, queue: .main)
         let interruptSource = DispatchSource.makeSignalSource(signal: SIGINT, queue: .main)
         signal(SIGTERM, SIG_IGN)
         signal(SIGINT, SIG_IGN)
 
         shutdownSource.setEventHandler {
             print("\n[SwiftLM] Received SIGTERM, shutting down gracefully...")
+            emitEvent(["event": "exiting", "reason": "requested"])
             Darwin.exit(0)
         }
         interruptSource.setEventHandler {
             print("\n[SwiftLM] Received SIGINT, shutting down gracefully...")
+            emitEvent(["event": "exiting", "reason": "requested"])
             Darwin.exit(0)
         }
         shutdownSource.resume()

docs/AEGIS_INTEGRATION.md

@@ -47,6 +47,18 @@ The server will emit a machine-readable JSON ready event on stdout when it is re
 
 Aegis-AI should **wait for this event** before routing any requests to the server.
 
+The server also emits a machine-readable JSON `exiting` event on stdout
+before a clean, planned shutdown (SIGTERM/SIGINT):
+
+```json
+{"event":"exiting","reason":"requested"}
+```
+
+`reason: "requested"` means this shutdown was expected (e.g. Aegis-AI
+called `stop`) — not a crash. This is the first of what may grow into a
+small set of self-reported exit reasons; consumers should ignore any
+`reason` value they don't recognize rather than treat it as an error.
+
 ---
 
 ## 🧠 Running 122B+ MoE Models (Critical)