feat(dsh): add DeepSeek Harness (dsh) agent support

[baizhu945]

Summary

Adds a first-class DeepSeek Harness (dsh) agent to cc-connect. Users can chat with dsh through Feishu/Telegram/... with full multi-turn context, live tool-call visibility, and interactive permission approval cards.

How it works

• Each user message spawns dsh --profile headless as a one-shot run that resumes the same persisted dsh session (--session-id, create-or-resume), so conversation context carries across turns.
• --model / --mode are passed on every run, making /model and /mode work like other agents:
  • /model reads dsh's settings.yaml model catalog (fallback: deepseek-v4-flash / deepseek-v4-pro)
  • /mode exposes read-only / workspace-write / danger-full-access / confirm
• In --jsonl mode (the dsh headless driver protocol this feature builds on):
  • text/thinking deltas and tool calls stream into the chat in real time
  • approval requests (confirm-mode write/execute interception + workspace-write sandbox escalations) render as permission cards; the human's Allow/Deny is written back to the runner's stdin via RespondPermission
• /session shows dsh's real session titles (last session/title event, fallback first user message), parsed from the zstd-compressed session logs (new dep: klauspost/compress).

Companion change (not in this PR)

The dsh side needs --session-id / --model / --mode / --jsonl headless-runner flags. Those live in deepseek-ai/deepseek-harness, which currently does not accept external pull requests (per its CONTRIBUTING.md). The headless runner changes are small and self-contained (startup flag parsing + runner streaming/approval wiring + confirm-mode ask interception + regression tests) — the patch is documented in the config example.

Testing

• go test -tags no_web ./... — all packages pass (LANG=C; one pre-existing locale-dependent core test fails under zh_CN only, unrelated to this change)
• go test ./core/ -run TestCUJ — passes
• New unit tests cover: session create/resume id flow, --jsonl event mapping (text/thinking/tool call/result), approval request relay + stdin response (allow & reject), session-title parsing from zstd logs, mode/model switching
• End-to-end verified against a real dsh headless build: approval → tool executes; rejection → Error: the user rejected tool "write" and the file is not created

Notes

• No breaking changes; new agent type dsh is additive.
• i18n: no new user-facing strings (reuses existing Msg* keys).

[baizhu945]

CI is fully green ✅ (lint, unit-test with -race, smoke, regression, performance).

One extra fix landed during review: drain stdout to EOF before cmd.Wait — cmd.Wait() closes the stdout pipe, and waiting on it before the reader goroutine finished could discard JSONL lines still buffered in the pipe (tool calls, result/done envelopes), silently dropping streamed events under race-detector scheduling. The race-detector CI run caught it; the reader now drains to EOF first, then Wait reaps the child.

Local verification summary:

• golangci-lint run --new-from-rev <base> ./... — no new findings
• go test -tags no_web ./... (LANG=C) — all packages pass; the single zh_CN-locale-dependent core test (TestRunShellWithProgress_NonexistentCommand) is pre-existing and unrelated (passes with LANG=C)
• go test -race ./agent/dsh/ — 6/6 stable after the pipe fix
• go test ./core/ -run TestCUJ — passes

[baizhu945]

One more fix landed after real-world testing: close stdin before cmd.Wait so a completed turn never leaves the session busy.

Symptom: after the first question, the AI finished and replied, but a second message was queued ("will be processed after the current task completes") until /stop was sent. Root cause: after the done envelope the dsh one-shot waits for the driver to close stdin before its approval readline sees EOF and the process exits — while Send held stdin open until cmd.Wait returned, so a finished turn still occupied the session forever.

Fix (with the companion dsh-side change): the reader drains stdout to EOF, then cc-connect closes stdin before cmd.Wait, and the dsh runner also closes its readline after the turn (belt and suspenders). Verified end-to-end: the spawned process now exits promptly after done with stdin held open, and consecutive turns run back-to-back without /stop.