M0: compilable skeleton — Kigi 0.1.0 fork surgery

Hard fork of xai-org/grok-build (Apache-2.0) re-targeted as Kigi, an
unofficial Kimi Code CLI community build.

Rename & identity
- 72 xai-*/xai-grok-* crates -> kigi-* (explicit: xai-grok-pager-bin ->
  kigi-bin [binary `kigi`], xai-grok-pager -> kigi-tui; rest mechanical);
  ptyctl, ptyctl-cli, third_party/ unchanged; proto package
  xai.grok.tools.v1 -> kigi.tools.v1
- Config home ~/.kigi (KIGI_SHARE_DIR override), env prefix GROK_* ->
  KIGI_*, `kigi --version` carries the unofficial-community-build notice
- clap identity, help text, startup banner, prompt templates rebranded
  (templates re-encrypted)

Deletions (PRD removal list #5/#6/#7/#9/#10)
- voice input (xai-grok-voice) and all TUI wiring
- telemetry: Mixpanel client, external OTel stream, Sentry, OTLP layers,
  trace/GCS/S3 upload queues (kigi-file-utils halved), workspace upload
  module & dc_log, heap-profile uploader, auth-diagnostics uploader,
  session-analytics halves of feedback; local zero-egress observability
  preserved in new kigi-log crate (unified log, --debug firehose,
  subsystem file logs, opt-in instrumentation)
- announcements (crate, remote-settings fields, TUI surfaces)
- plugin marketplace (crate, sources/browse/CTA/extensions-modal tab);
  direct plugin install/uninstall/update via kigi-agent git_install kept
- relay/gateway/assets endpoints and features (agent relay, headless
  relay transport, gateway bridge, LeaderEnvUrls); leader IPC socket now
  ~/.kigi/leader.sock + KIGI_LEADER_SOCKET, no ws-url derivation
- functional types rehomed instead of deleted: PermissionMode ->
  kigi-config-types, McpInitStrategy -> kigi-mcp, PrCreationSource ->
  session signals, TerminalDiagnostics -> kigi-pager-render, agent_id ->
  shell util

Endpoints
- kigi-env rewritten: single production KigiEndpoints {coding_api_base_url
  https://api.kimi.com/coding/v1 (KIGI_CODE_BASE_URL), oauth_host
  https://auth.kimi.com (KIGI_OAUTH_HOST), update_base_url (GitHub
  Releases API), upgrade_page_url}; GrokBuildEnvironment enum deleted

Toolchain & workspace hygiene
- Rust 1.97.0 pinned; edition 2024; full cargo update; git2 hoisted to
  workspace at 0.21 (Option->Result API migration), quick-xml 0.41
- Root Cargo.toml hand-maintained (PRD §8.1): version 0.1.0 inherited by
  all members, members sorted, unused deps pruned
- cargo-deny advisories gate (deny.toml with documented transitive
  exceptions); CI workflow (check/clippy/fmt/deny/test, macOS+Linux)
- cross-crate test seams re-gated behind `test-support` cargo feature;
  insta snapshot baselines renamed to the kigi_tui prefix
- clippy --workspace --all-targets: zero warnings; fmt clean

Fixes surfaced by the port
- updater probe/installer divergence (bin/kigi vs bin/grok symlink set)
- idle model-metadata refresh dead under KIGI_CODE_BASE_URL override
  (new is_effective_coding_endpoint_url, loopback+override aware)
- macOS symlinked-TMPDIR fixture canonicalization (foreign_sessions,
  fast-worktree); RSS measurement tests serialized via serial_test

Docs & legal (Apache §4)
- NOTICE added (upstream attribution + change statement); THIRD-PARTY
  notices sustained; kigi-tools ported-code notices extended; README,
  CONTRIBUTING, SECURITY, AGENTS.md rewritten

Out of scope for M0 (tracked): Kimi auth/inference (M1), search/fetch,
command parity, config import (M2), Computer Hub excision & final
brand-token sweep (M2), distribution & self-update rewrite (M3).

crates/codegen/kigi-shell/src/session/announcement_state.rs

@@ -0,0 +1,119 @@
+//! Persisted announcement tracking state for session resumption.
+//!
+//! Tracks which MCP servers and skills have already been announced
+//! via `<system-reminder>` messages so that resumed sessions don't
+//! re-inject duplicate listings.
+
+use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet};
+
+/// Persisted announcement tracking state.
+///
+/// Restored on session resume so the fresh actor "remembers" what was
+/// already announced.  The existing delta/fingerprint comparison logic
+/// then correctly handles changes (new/removed/updated servers or skills)
+/// without creating duplicates.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AnnouncementState {
+    /// Fingerprints of MCP servers that have been announced.
+    /// Maps server_name → `McpServerFingerprint`.
+    ///
+    /// The hash values use FNV-1a (deterministic, portable) so that
+    /// persisted fingerprints remain valid across Rust versions, build
+    /// profiles, and CPU architectures.
+    pub mcp_server_fingerprints: HashMap<String, McpServerFingerprint>,
+
+    /// Names of skills already announced via system-reminder.
+    /// Uses the skill's `dedup_key()` (which is the skill name).
+    pub announced_skill_names: HashSet<String>,
+}
+
+/// Serializable MCP server fingerprint for persistence.
+///
+/// This is the serializable counterpart of the in-memory
+/// `ServerFingerprint` type alias `(usize, u64, u64)`.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct McpServerFingerprint {
+    pub tool_count: usize,
+    pub description_hash: u64,
+    pub tool_names_hash: u64,
+}
+
+/// Convert from in-memory fingerprint map to persistable map.
+pub fn to_persisted_fingerprints(
+    in_memory: &HashMap<String, (usize, u64, u64)>,
+) -> HashMap<String, McpServerFingerprint> {
+    in_memory
+        .iter()
+        .map(|(name, &(tc, dh, tnh))| {
+            (
+                name.clone(),
+                McpServerFingerprint {
+                    tool_count: tc,
+                    description_hash: dh,
+                    tool_names_hash: tnh,
+                },
+            )
+        })
+        .collect()
+}
+
+/// Convert from persisted fingerprint map to in-memory map.
+pub fn from_persisted_fingerprints(
+    persisted: &HashMap<String, McpServerFingerprint>,
+) -> HashMap<String, (usize, u64, u64)> {
+    persisted
+        .iter()
+        .map(|(name, fp)| {
+            (
+                name.clone(),
+                (fp.tool_count, fp.description_hash, fp.tool_names_hash),
+            )
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn serde_round_trip() {
+        let state = AnnouncementState {
+            mcp_server_fingerprints: HashMap::from([(
+                "github".to_string(),
+                McpServerFingerprint {
+                    tool_count: 5,
+                    description_hash: 12345678,
+                    tool_names_hash: 87654321,
+                },
+            )]),
+            announced_skill_names: HashSet::from(["commit".to_string(), "review".to_string()]),
+        };
+        let json = serde_json::to_string(&state).unwrap();
+        let loaded: AnnouncementState = serde_json::from_str(&json).unwrap();
+        assert_eq!(loaded.mcp_server_fingerprints.len(), 1);
+        assert_eq!(loaded.announced_skill_names.len(), 2);
+        let fp = &loaded.mcp_server_fingerprints["github"];
+        assert_eq!(fp.tool_count, 5);
+        assert_eq!(fp.description_hash, 12345678);
+        assert_eq!(fp.tool_names_hash, 87654321);
+    }
+
+    #[test]
+    fn backward_compat_empty_json() {
+        let loaded: AnnouncementState = serde_json::from_str("{}").unwrap();
+        assert!(loaded.mcp_server_fingerprints.is_empty());
+        assert!(loaded.announced_skill_names.is_empty());
+    }
+
+    #[test]
+    fn fingerprint_conversion_round_trip() {
+        let in_memory: HashMap<String, (usize, u64, u64)> =
+            HashMap::from([("srv".to_string(), (3, 111, 222))]);
+        let persisted = to_persisted_fingerprints(&in_memory);
+        let back = from_persisted_fingerprints(&persisted);
+        assert_eq!(in_memory, back);
+    }
+}