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/ptyctl/src/pty.rs

@@ -0,0 +1,155 @@
+//! PTY wrapper using `portable-pty` for cross-platform pseudoterminal support.
+
+use std::collections::HashMap;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use portable_pty::{CommandBuilder, MasterPty, PtySize, native_pty_system};
+
+/// Configuration for spawning a PTY session.
+#[derive(Debug, Clone)]
+pub struct PtyConfig {
+    /// Command and arguments to run.
+    pub command: Vec<String>,
+    /// Terminal width in columns.
+    pub cols: u16,
+    /// Terminal height in rows.
+    pub rows: u16,
+    /// Working directory.
+    pub cwd: Option<PathBuf>,
+    /// Additional environment variables.
+    pub env: HashMap<String, String>,
+}
+
+/// Handle to a running PTY session.
+pub struct PtyHandle {
+    master: Box<dyn MasterPty + Send>,
+    child: Box<dyn portable_pty::Child + Send>,
+    reader: Box<dyn Read + Send>,
+    writer: Box<dyn Write + Send>,
+}
+
+/// Resize-capable master half of a dismantled [`PtyHandle`].
+///
+/// portable-pty's unix master is not `Sync` (interior `RefCell`), so it sits
+/// behind a mutex that is only held for the synchronous resize ioctl.
+pub struct PtyMaster {
+    master: std::sync::Mutex<Box<dyn MasterPty + Send>>,
+}
+
+impl PtyMaster {
+    /// Resize the PTY (TIOCSWINSZ; the kernel delivers SIGWINCH to the child).
+    pub fn resize(&self, cols: u16, rows: u16) -> Result<()> {
+        self.master
+            .lock()
+            .unwrap()
+            .resize(PtySize {
+                rows,
+                cols,
+                pixel_width: 0,
+                pixel_height: 0,
+            })
+            .context("failed to resize PTY")
+    }
+}
+
+/// Child-process half of a dismantled [`PtyHandle`].
+pub struct PtyChild {
+    child: Box<dyn portable_pty::Child + Send>,
+}
+
+impl PtyChild {
+    /// Check if the child process is still alive.
+    pub fn is_alive(&mut self) -> bool {
+        self.child.try_wait().ok().flatten().is_none()
+    }
+
+    /// Get the child process ID.
+    pub fn pid(&self) -> Option<u32> {
+        self.child.process_id()
+    }
+
+    /// Wait for the child to exit and return the exit code.
+    pub fn wait(&mut self) -> Result<u32> {
+        let status = self.child.wait().context("failed to wait for child")?;
+        Ok(status.exit_code())
+    }
+
+    /// Kill the child process.
+    pub fn kill(&mut self) -> Result<()> {
+        self.child.kill().context("failed to kill child process")
+    }
+}
+
+impl PtyHandle {
+    /// Spawn a new process in a PTY.
+    pub fn spawn(config: &PtyConfig) -> Result<Self> {
+        let pty_system = native_pty_system();
+
+        let pty_size = PtySize {
+            rows: config.rows,
+            cols: config.cols,
+            pixel_width: 0,
+            pixel_height: 0,
+        };
+
+        let pair = pty_system.openpty(pty_size).context("failed to open PTY")?;
+
+        let mut cmd = CommandBuilder::new(&config.command[0]);
+        if config.command.len() > 1 {
+            cmd.args(&config.command[1..]);
+        }
+        if let Some(ref cwd) = config.cwd {
+            cmd.cwd(cwd);
+        }
+        for (key, value) in &config.env {
+            cmd.env(key, value);
+        }
+        // Set TERM for proper terminal detection.
+        cmd.env("TERM", "xterm-256color");
+        cmd.env("COLORTERM", "truecolor");
+
+        let child = pair
+            .slave
+            .spawn_command(cmd)
+            .context("failed to spawn command in PTY")?;
+
+        let reader = pair
+            .master
+            .try_clone_reader()
+            .context("failed to clone PTY reader")?;
+
+        let writer = pair
+            .master
+            .take_writer()
+            .context("failed to take PTY writer")?;
+
+        Ok(Self {
+            master: pair.master,
+            child,
+            reader,
+            writer,
+        })
+    }
+
+    /// Dismantle into the master half (kept for resize), the child half
+    /// (moved into a waiter task), and the reader/writer streams.
+    pub fn into_parts(
+        self,
+    ) -> (
+        PtyMaster,
+        PtyChild,
+        Box<dyn Read + Send>,
+        Box<dyn Write + Send>,
+    ) {
+        (
+            PtyMaster {
+                master: std::sync::Mutex::new(self.master),
+            },
+            PtyChild { child: self.child },
+            self.reader,
+            self.writer,
+        )
+    }
+}