cc-session-control 0.7.3__tar.gz → 0.7.5__tar.gz

{cc_session_control-0.7.3/src/cc_session_control.egg-info → cc_session_control-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-control
-Version: 0.7.3
+Version: 0.7.5
 Summary: TUI manager for Claude Code sessions and Remote Control
 Author: dzshzx
 License-Expression: MIT
@@ -12,18 +12,26 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: urwid>=2.0.0
 Provides-Extra: dev
+Requires-Dist: coverage>=7.6; extra == "dev"
+Requires-Dist: mypy>=1.15; extra == "dev"
 Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=6.0; extra == "dev"
+Requires-Dist: pyyaml>=6.0; extra == "dev"
+Requires-Dist: ruff>=0.12; extra == "dev"
 Dynamic: license-file
 
 # cc-session-control
 
-TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Control.
+tmux-first TUI and headless CLI for [Claude Code](https://claude.ai/code)
+sessions, background agents, and Remote Control.
 
 **CLI command: `csctl`**
 
@@ -41,7 +49,8 @@ Built with [urwid](https://urwid.org/).
 
 - Python 3.12+
 - [Claude Code](https://claude.ai/code) CLI installed and authenticated
-- tmux (for Remote Control management)
+- tmux (the primary session-lifecycle carrier: launch, resume, background, and
+  survive terminal/SSH disconnects; managed Remote Control servers also use it)
 - Linux / WSL (macOS support is partial — `/proc`-based liveness detection is Linux-only)
 
 ## Installation
@@ -89,6 +98,10 @@ csctl rc list            # Show auto-start list
 # Session cleanup
 csctl prune                          # Dry run: show stats
 csctl prune --max-prompts 1 --apply  # Delete sessions with ≤1 prompt
+csctl prune --sweep-orphans          # Dry run: orphan sid-keyed artifact dirs
+csctl prune --sweep-zombies          # Dry run: dead sessions/<pid>.json files
+csctl prune --sweep-aged             # Dry run: age-keyed global entries
+# Add --apply to exactly one of the sweep commands above to execute it.
 
 # Resume rescue (headless): list sessions across directories with
 # ready-to-copy resume commands (native /resume only searches the cwd
@@ -98,6 +111,10 @@ csctl resume mybug           # Keyword: sid/cwd/title, then transcript body
 csctl resume --page 2        # Next page
 csctl resume --all           # Everything, no paging
 
+# Read-only inventory
+csctl agents                 # Background agents: state, tempo, name, cwd
+csctl env                    # Current + orphan bridge environments
+
 # Bundled Claude Code skill (session-doctor knowledge for the agent)
 csctl skill install          # Write SKILL.md to ~/.claude/skills/
 csctl skill install --force  # Replace an existing skill directory
@@ -114,10 +131,13 @@ csctl --version
 |---|---|---|
 | `CSCTL_RC_SESSION` | `rc` | tmux session name for RC servers |
 | `CSCTL_RC_STAGGER` | `2` | Seconds between starting RC servers |
+| `CSCTL_CLEANUP_AGE_DAYS` | `14` | Minimum age in days for `csctl prune --sweep-aged` (must be an integer ≥ 1) |
 | `CSCTL_THEME` | `auto` | TUI palette: `auto` (detect the terminal background via OSC 11 / `$COLORFGBG`) / `dark` / `light`. tmux typically doesn't answer the OSC 11 query, so inside tmux `auto` falls back to `dark` — set this (or `--theme`) explicitly for a light terminal |
 | `XDG_CONFIG_HOME` | `~/.config` | Config directory base |
 
-RC auto-start list is stored at `$XDG_CONFIG_HOME/csctl/rc-enabled`.
+The RC auto-start list is stored at
+`$XDG_CONFIG_HOME/csctl/rc-enabled`; the bridge-environment ledger is stored
+at `$XDG_CONFIG_HOME/csctl/environments.jsonl`.
 
 ## License
 

{cc_session_control-0.7.3 → cc_session_control-0.7.5}/README.md

@@ -1,6 +1,7 @@
 # cc-session-control
 
-TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Control.
+tmux-first TUI and headless CLI for [Claude Code](https://claude.ai/code)
+sessions, background agents, and Remote Control.
 
 **CLI command: `csctl`**
 
@@ -18,7 +19,8 @@ Built with [urwid](https://urwid.org/).
 
 - Python 3.12+
 - [Claude Code](https://claude.ai/code) CLI installed and authenticated
-- tmux (for Remote Control management)
+- tmux (the primary session-lifecycle carrier: launch, resume, background, and
+  survive terminal/SSH disconnects; managed Remote Control servers also use it)
 - Linux / WSL (macOS support is partial — `/proc`-based liveness detection is Linux-only)
 
 ## Installation
@@ -66,6 +68,10 @@ csctl rc list            # Show auto-start list
 # Session cleanup
 csctl prune                          # Dry run: show stats
 csctl prune --max-prompts 1 --apply  # Delete sessions with ≤1 prompt
+csctl prune --sweep-orphans          # Dry run: orphan sid-keyed artifact dirs
+csctl prune --sweep-zombies          # Dry run: dead sessions/<pid>.json files
+csctl prune --sweep-aged             # Dry run: age-keyed global entries
+# Add --apply to exactly one of the sweep commands above to execute it.
 
 # Resume rescue (headless): list sessions across directories with
 # ready-to-copy resume commands (native /resume only searches the cwd
@@ -75,6 +81,10 @@ csctl resume mybug           # Keyword: sid/cwd/title, then transcript body
 csctl resume --page 2        # Next page
 csctl resume --all           # Everything, no paging
 
+# Read-only inventory
+csctl agents                 # Background agents: state, tempo, name, cwd
+csctl env                    # Current + orphan bridge environments
+
 # Bundled Claude Code skill (session-doctor knowledge for the agent)
 csctl skill install          # Write SKILL.md to ~/.claude/skills/
 csctl skill install --force  # Replace an existing skill directory
@@ -91,10 +101,13 @@ csctl --version
 |---|---|---|
 | `CSCTL_RC_SESSION` | `rc` | tmux session name for RC servers |
 | `CSCTL_RC_STAGGER` | `2` | Seconds between starting RC servers |
+| `CSCTL_CLEANUP_AGE_DAYS` | `14` | Minimum age in days for `csctl prune --sweep-aged` (must be an integer ≥ 1) |
 | `CSCTL_THEME` | `auto` | TUI palette: `auto` (detect the terminal background via OSC 11 / `$COLORFGBG`) / `dark` / `light`. tmux typically doesn't answer the OSC 11 query, so inside tmux `auto` falls back to `dark` — set this (or `--theme`) explicitly for a light terminal |
 | `XDG_CONFIG_HOME` | `~/.config` | Config directory base |
 
-RC auto-start list is stored at `$XDG_CONFIG_HOME/csctl/rc-enabled`.
+The RC auto-start list is stored at
+`$XDG_CONFIG_HOME/csctl/rc-enabled`; the bridge-environment ledger is stored
+at `$XDG_CONFIG_HOME/csctl/environments.jsonl`.
 
 ## License
 

{cc_session_control-0.7.3 → cc_session_control-0.7.5}/pyproject.toml

@@ -17,6 +17,8 @@ classifiers = [
     "Environment :: Console",
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: User Interfaces",
 ]
 
@@ -29,7 +31,14 @@ Issues = "https://github.com/dzshzx/cc-session-control/issues"
 csctl = "cc_session_control.cli:main"
 
 [project.optional-dependencies]
-dev = ["pytest>=7.0"]
+dev = [
+    "coverage>=7.6",
+    "mypy>=1.15",
+    "pytest>=7.0",
+    "pytest-cov>=6.0",
+    "pyyaml>=6.0",
+    "ruff>=0.12",
+]
 
 [tool.setuptools.dynamic]
 version = { attr = "cc_session_control.__version__" }
@@ -39,3 +48,34 @@ where = ["src"]
 
 [tool.setuptools.package-data]
 cc_session_control = ["skill/SKILL.md"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "BLE"]
+# Ruff's formatter deliberately leaves some long strings and comments intact,
+# so format output, rather than E501, is the single line-wrapping authority.
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.12"
+files = ["src"]
+check_untyped_defs = true
+warn_unused_configs = true
+
+[[tool.mypy.overrides]]
+module = ["urwid"]
+# Keep the third-party widget boundary dynamic while checking every
+# cc_session_control module and every project-owned type contract.
+ignore_missing_imports = true
+follow_imports = "skip"
+
+[tool.coverage.run]
+branch = true
+relative_files = true
+source = ["cc_session_control"]
+
+[tool.coverage.report]
+show_missing = true

{cc_session_control-0.7.3 → cc_session_control-0.7.5}/src/cc_session_control/__init__.py

@@ -1,3 +1,3 @@
 """cc-session-control — TUI manager for Claude Code sessions and Remote Control."""
 
-__version__ = "0.7.3"
+__version__ = "0.7.5"

{cc_session_control-0.7.3 → cc_session_control-0.7.5}/src/cc_session_control/__main__.py

@@ -2,4 +2,4 @@
 
 from .cli import main
 
-main()
+raise SystemExit(main())

cc_session_control-0.7.5/src/cc_session_control/actions/agent_ops.py

@@ -0,0 +1,351 @@
+"""Background-agent lifecycle actions (R4 / Phase 6).
+
+The persistent truth for a background agent lives in `jobs/<short>/state.json`
+(registry.read_agent_jobs → AgentJob); it carries NO pid. So a live worker's host
+pid is resolved by JOINing the job's sid back to `sessions/<pid>.json`
+(the production takeover path does this inside one typed liveness snapshot;
+`job_host` is records-only compatibility) — a live worker with no sessions file
+is therefore unstoppable, a documented orphan risk surfaced in `HELP`.
+
+Capability red lines honoured here:
+  - respawn/takeover never replace the csctl process (respawn spawns a tmux
+    window; takeover hands a Session to the existing `do_resume` path run AFTER
+    the UI loop exits).
+  - stop only signals a confirmed-live joined host pid; killing a
+    `--remote-control`/bg worker does not always fully reap it (orphan risk).
+  - destructive ops (remove/stop) refuse when "current" can't be determined
+    (no `/proc`, R10) so they never blind-hit csctl's own session.
+
+This is an action module: internals are English, but the user-facing label/help
+constants the (Phase 7) background view reads are Simplified Chinese.
+"""
+
+from __future__ import annotations
+
+import shlex
+from collections import deque
+from dataclasses import dataclass
+from enum import Enum
+
+from ..config import cfg
+from ..data import cleanup, liveness, registry, tmux
+from ..data import proc as proc
+from ..data.removal import CleanupExecution
+from ..models import AgentJob, Session
+from . import session_ops
+
+# --- host-pid join (resume-takeover compatibility view) -----------------------
+
+
+def job_host(job: AgentJob, *, max_age: float = 5.0) -> tuple[int | None, bool]:
+    """Resolve a background job's host pid + liveness — `(pid, alive)`.
+
+    `state.json` has no pid, so the worker's pid is JOINed from
+    `sessions/<pid>.json` on `job.sid` (a bg session proc; `kind` is typically
+    "bg"). Prefers a `/proc`-confirmed live match (so `alive=True` is trustworthy
+    and defeats pid reuse via `procStart`); falls back to the first sid match
+    with `alive=False`. Returns `(None, False)` when no sessions file exists for
+    the sid — that live worker is unstoppable (documented orphan risk).
+
+    Injects `/proc` liveness onto the registry rows, then defers to the single
+    pure join `registry.host_pid_for_sid` (shared with `snapshot._enrich_jobs`).
+    """
+    procs = liveness.live_session_procs(max_age=max_age)
+    return registry.host_pid_for_sid(job.sid, procs)
+
+
+# --- respawn ------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class RespawnResult:
+    """Exact command plus the tmux target that proves it was launched."""
+
+    command: str
+    target: str | None
+    detail: str = ""
+    tmux_result: tmux.TmuxWriteResult | None = None
+
+    @property
+    def success(self) -> bool:
+        return self.target is not None
+
+
+def respawn_cmd(job: AgentJob) -> str:
+    """The exact relaunch command: `claude --resume <resume_sid> <flags> --bg`.
+
+    Pure string build via `shlex.join` (split from `respawn` so it can be copied
+    to the clipboard / asserted in tests). `respawn_flags` are reused verbatim
+    from the recorded job state.
+    """
+    args = ["claude", "--resume", job.resume_sid, *job.respawn_flags, "--bg"]
+    return shlex.join(args)
+
+
+def _job_window(job: AgentJob) -> str:
+    """tmux window name for a respawned agent (name or short, suffixed)."""
+    base = (job.name or "bg").strip() or "bg"
+    return f"{base}-{job.short[:8]}"
+
+
+def respawn_result(job: AgentJob) -> RespawnResult:
+    """Relaunch a background agent while retaining the tmux outcome."""
+    cmd = respawn_cmd(job)
+    result = tmux.run_in_tmux_result(
+        tmux.session_name_for(job.cwd),
+        _job_window(job),
+        cmd,
+    )
+    target = result.target if result.success else None
+    return RespawnResult(cmd, target, result.diagnostic, result)
+
+
+# --- remove (settled agents only) ---------------------------------------------
+
+
+def remove_job(job: AgentJob) -> CleanupExecution:
+    """Remove a SETTLED background agent: `jobs/<short>/` + its sid artifacts.
+
+    The public data-layer executor owns the final fresh liveness check, so no
+    caller-held evidence can authorize deletion.
+    """
+    result = CleanupExecution()
+    try:
+        anchors = cleanup.agent_removal_anchors(job.short, job.sid)
+    except OSError as exc:
+        result.refuse([job.short], f"cannot establish removal anchor: {exc}")
+        return result
+    return cleanup.remove_agent_artifacts(job.short, job.sid, anchors=anchors)
+
+
+# --- watch (read-only) --------------------------------------------------------
+
+_TIMELINE_LINE_LIMIT = 200
+
+
+class TimelineReadState(Enum):
+    READY = "ready"
+    MISSING = "missing"
+    FAILED = "failed"
+
+
+@dataclass(frozen=True)
+class TimelineReadResult:
+    """Bounded timeline data for a main-loop read-only overlay."""
+
+    state: TimelineReadState
+    lines: tuple[str, ...] = ()
+    detail: str = ""
+
+
+def watch(job: AgentJob) -> TimelineReadResult:
+    """Stream the last 200 timeline lines without loading the whole file."""
+    path = cfg.jobs_dir / job.short / "timeline.jsonl"
+    try:
+        with open(path, errors="ignore") as fh:
+            lines = deque(
+                (line.rstrip("\r\n") for line in fh),
+                maxlen=_TIMELINE_LINE_LIMIT,
+            )
+    except FileNotFoundError:
+        return TimelineReadResult(TimelineReadState.MISSING)
+    except OSError as exc:
+        return TimelineReadResult(TimelineReadState.FAILED, detail=str(exc))
+    return TimelineReadResult(TimelineReadState.READY, tuple(lines))
+
+
+# --- resume takeover (reuses the existing foreground resume path) -------------
+
+
+class TakeoverPreparationState(Enum):
+    """Whether one fresh generation permits constructing a takeover session."""
+
+    READY = "ready"
+    REFUSED = "refused"
+
+
+@dataclass(frozen=True)
+class TakeoverPreparationResult:
+    """Typed result of preparing one background-agent takeover."""
+
+    state: TakeoverPreparationState
+    session: Session | None = None
+    detail: str = ""
+
+
+def _ready_takeover(
+    job: AgentJob,
+    *,
+    pid: int | None = None,
+    alive: bool = False,
+    current: bool = False,
+    proc_start: str = "",
+    tmux_target: str | None = None,
+) -> TakeoverPreparationResult:
+    """Build the existing resume-path adapter for one prepared agent."""
+    return TakeoverPreparationResult(
+        TakeoverPreparationState.READY,
+        session=Session(
+            sid=job.resume_sid,
+            cwd=job.cwd,
+            label=job.name or job.short,
+            mtime=0.0,
+            prompts=0,
+            pid=pid,
+            alive=alive,
+            current=current,
+            proc_start=proc_start,
+            source="bg",
+            agent_short=job.short,
+            tmux_target=tmux_target,
+        ),
+    )
+
+
+def prepare_takeover(job: AgentJob) -> TakeoverPreparationResult:
+    """Prepare one background-agent resume without widening destructive gates.
+
+    Bringing a bg session to the foreground is just a resume of its
+    `resume_sid`, so a ready result carries the Session the view feeds to the SAME
+    `app.exit_with(ResumeIntent)` → `do_resume` pipeline used for foreground sessions —
+    all kill/exec/`_resume_plan` logic is reused, none duplicated (R4.4 takeover).
+
+    The published immutable ``job.host_alive`` decides whether this action can
+    kill. A dead job resumes directly without acquiring liveness or tmux state.
+    A live job acquires exactly one fresh typed generation; incomplete registry,
+    process, ancestor, or agents evidence is refused before any tmux lookup.
+    Host identity, liveness, proc-start, and current-session protection all come
+    from that same generation. If it proves the former host is gone, the action
+    safely contracts to the same non-destructive dead resume.
+    """
+    if not job.host_alive:
+        return _ready_takeover(job)
+
+    evidence = liveness.liveness_inputs()
+    if not evidence.complete:
+        return TakeoverPreparationResult(
+            TakeoverPreparationState.REFUSED,
+            detail=_incomplete_liveness_detail(evidence),
+        )
+    pid, alive = registry.host_pid_for_sid(job.sid, evidence.session_procs)
+    if not alive or pid is None:
+        return _ready_takeover(job)
+
+    proc_start = next(
+        (
+            item.proc_start
+            for item in evidence.session_procs
+            if item.sid == job.sid and item.pid == pid and item.proc_alive is True
+        ),
+        "",
+    )
+    residency = tmux.find_session_window_result([pid])
+    if not residency.complete:
+        detail = "; ".join(
+            f"{issue.source}"
+            + (f" at {issue.path}" if issue.path else "")
+            + f": {issue.detail}"
+            for issue in residency.issues
+        )
+        return TakeoverPreparationResult(
+            TakeoverPreparationState.REFUSED,
+            detail=detail,
+        )
+    return _ready_takeover(
+        job,
+        pid=pid,
+        alive=True,
+        current=pid in evidence.cur,
+        proc_start=proc_start,
+        tmux_target=residency.target,
+    )
+
+
+# --- stop (live workers only) -------------------------------------------------
+
+
+class AgentStopState(Enum):
+    """Observable outcome of stopping one background agent."""
+
+    STOPPED = "stopped"
+    NOT_RUNNING = "not-running"
+    REFUSED = "refused"
+    FAILED = "failed"
+
+
+@dataclass(frozen=True)
+class AgentStopResult:
+    state: AgentStopState
+    pid: int | None = None
+    detail: str = ""
+
+    @property
+    def success(self) -> bool:
+        return self.state is AgentStopState.STOPPED
+
+
+def _incomplete_liveness_detail(evidence: liveness.LivenessSnapshot) -> str:
+    issues = []
+    for issue in evidence.issues:
+        location = f" at {issue.path}" if issue.path else ""
+        issues.append(f"{issue.source}{location}: {issue.detail}")
+    return "liveness evidence incomplete: " + "; ".join(issues)
+
+
+def stop_job_result(job: AgentJob) -> AgentStopResult:
+    """Stop one live background agent from one fresh liveness snapshot.
+
+    The host pid is JOINed from `sessions/<pid>.json` (`job_host`); only a
+    confirmed-live pid is killed. Incomplete source evidence and unavailable
+    current-session determination refuse the destructive action. The same
+    snapshot supplies both the host pid and its proc-start identity, avoiding
+    a second compatibility scan before ``take_over_result`` rechecks liveness.
+
+    The kill itself is `session_ops.take_over_result` (the ONE primitive: R10 gate,
+    recheck, SIGTERM, cache invalidation). Its four outcomes map one-for-one to
+    this domain result.
+
+    Killing does not always fully reap a `--remote-control`/bg worker (orphan
+    risk, see `HELP`).
+    """
+    evidence = liveness.liveness_inputs()
+    if not evidence.complete:
+        return AgentStopResult(
+            AgentStopState.REFUSED,
+            detail=_incomplete_liveness_detail(evidence),
+        )
+    pid, alive = registry.host_pid_for_sid(job.sid, evidence.session_procs)
+    if not alive or not pid:
+        return AgentStopResult(
+            AgentStopState.NOT_RUNNING,
+            pid=pid,
+            detail="no live host for background agent",
+        )
+    proc_start = next(
+        (
+            item.proc_start
+            for item in evidence.session_procs
+            if item.sid == job.sid and item.pid == pid
+        ),
+        "",
+    )
+    outcome = session_ops.take_over_result(pid, proc_start)
+    if outcome.state is session_ops.TakeOverState.KILLED:
+        return AgentStopResult(AgentStopState.STOPPED, pid=pid)
+    if outcome.state is session_ops.TakeOverState.GONE:
+        return AgentStopResult(
+            AgentStopState.NOT_RUNNING,
+            pid=pid,
+            detail="background agent host is no longer running",
+        )
+    if outcome.state is session_ops.TakeOverState.REFUSED:
+        return AgentStopResult(
+            AgentStopState.REFUSED,
+            pid=pid,
+            detail=outcome.detail or "current session cannot be determined",
+        )
+    return AgentStopResult(
+        AgentStopState.FAILED,
+        pid=pid,
+        detail=outcome.detail or "failed to signal background agent host",
+    )

cc_session_control-0.7.5/src/cc_session_control/actions/feedback.py

@@ -0,0 +1,77 @@
+"""Operator-facing summaries for typed cleanup execution results."""
+
+from __future__ import annotations
+
+from ..data.removal import CleanupExecution
+
+
+def _protection_issue(result: CleanupExecution) -> str:
+    issue = result.issues[0]
+    where = f"（{issue.path}）" if issue.path else ""
+    return f"{issue.source}{where}：{issue.error}"
+
+
+def _details(result: CleanupExecution) -> list[str]:
+    details: list[str] = []
+    if result.failed and result.removed:
+        details.append(f"已删除路径 {len(result.removed)}")
+    if result.failed:
+        first = result.failed[0]
+        detail = f"失败 {len(result.failed)}"
+        if first.error:
+            detail += f"（{first.path}: {first.error}）"
+        details.append(detail)
+    if result.skipped:
+        details.append(f"跳过 {len(result.skipped)}（{result.skipped[0].reason}）")
+    if result.refused:
+        details.append(f"拒绝 {len(result.refused)}（{result.refused[0].reason}）")
+    if result.missing_targets:
+        details.append(f"已不存在 {len(result.missing_targets)}")
+    return details
+
+
+def format_cleanup_notice(result: CleanupExecution, done_template: str) -> str:
+    """Summarize multi-target cleanup without turning partial work into success."""
+    if result.issues and not result.removed:
+        return f"保护证据不完整，未删除：{_protection_issue(result)}"
+    completed = len(result.completed)
+    details = _details(result)
+    if completed and not details:
+        return done_template.format(n=completed)
+    if completed:
+        return f"部分完成：{done_template.format(n=completed)}；" + "；".join(details)
+    if result.removed:
+        return "清理部分失败：" + "；".join(details)
+    if result.refused:
+        return "已拒绝清理：" + "；".join(details)
+    if result.failed:
+        return "清理失败：" + "；".join(details)
+    if details:
+        return "未清理任何项目：" + "；".join(details)
+    return "无可清理内容"
+
+
+def format_delete_notice(result: CleanupExecution) -> str:
+    """Summarize deletion of one session or background-agent artifact set."""
+    if result.issues and not result.removed:
+        return f"保护证据不完整，未删除：{_protection_issue(result)}"
+    if result.completed and not result.incomplete:
+        return "已删除"
+    if result.failed:
+        first = result.failed[0]
+        suffix = f"：{first.error}" if first.error else ""
+        if result.removed:
+            return (
+                f"删除部分失败：已删除路径 {len(result.removed)}；"
+                f"失败 {len(result.failed)}{suffix}"
+            )
+        return f"删除失败{suffix}"
+    if result.removed and result.incomplete:
+        return f"删除部分完成：已删除路径 {len(result.removed)}；" + "；".join(
+            _details(result)
+        )
+    if result.refused:
+        return f"拒绝删除：{result.refused[0].reason}"
+    if result.skipped:
+        return f"未删除：{result.skipped[0].reason}"
+    return "无可删除内容"