@hunyed15/codecgc 0.1.7 → 0.1.8

package/codecgcmcp/README.md

@@ -1,17 +1,63 @@
 # CodeCGC MCP Server
 
-This package contains the first minimal CodeCGC orchestrator MCP server.
+This package contains the CodeCGC orchestrator MCP server.
 
-Current scope:
+The server is the preferred Claude-facing capability layer. The CLI remains available for fallback, CI, and local debugging.
 
-- install
-- status
-- doctor
-- entry
-- continue
-- explain
-- review
-- history
-- route
+## Current Tool Surface
+
+- `codecgc.install`
+- `codecgc.start`
+- `codecgc.status`
+- `codecgc.doctor`
+- `codecgc.entry`
+- `codecgc.continue`
+- `codecgc.explain`
+- `codecgc.review`
+- `codecgc.history`
+- `codecgc.route`
+- `codecgc.plan`
+- `codecgc.build`
+- `codecgc.fix`
+- `codecgc.test`
+- `codecgc.package_audit`
+- `codecgc.external_audit`
+- `codecgc.external_status`
+- `codecgc.release_readiness`
+- `codecgc.lifecycle`
+
+## Runtime Boundary
 
 This server currently reuses the existing CodeCGC runtime scripts rather than replacing them.
+
+The contract is:
+
+- MCP tools expose product capabilities to Claude.
+- Runtime scripts own workflow behavior.
+- CLI commands stay as compatibility and maintainer surfaces.
+- MCP responses should be machine-readable JSON payloads.
+- `codecgc.external_status` is the concise panel view; `codecgc.external_audit` is the deeper consistency check.
+
+## Response Contract
+
+Every tool returns a stable envelope:
+
+```json
+{
+  "success": true,
+  "tool": "codecgc.status",
+  "payload": {},
+  "error": null,
+  "meta": {
+    "contract_version": "1.0",
+    "payload_success": true,
+    "response_shape": "codecgc.mcp.tool_result"
+  }
+}
+```
+
+The raw runtime response remains available under `payload`.
+
+See `codecgc/reference/mcp-tool-surface.md` for the full contract.
+
+Errors include a stable `error.category` field so Claude can distinguish runtime failures, invalid JSON, permission issues, missing scripts, and MCP wrapper exceptions without parsing text.

package/codecgcmcp/src/codecgcmcp/server.py

@@ -15,6 +15,16 @@ from codecgc_workflow_runtime import run_json_script
 
 mcp = FastMCP("CodeCGC MCP Server")
 
+MCP_CONTRACT_VERSION = "1.0"
+
+EXCEPTION_ERROR_CATEGORIES = {
+    "JSONDecodeError": "runtime-json-invalid",
+    "ValueError": "runtime-json-invalid",
+    "TimeoutExpired": "runtime-timeout",
+    "FileNotFoundError": "runtime-script-missing",
+    "PermissionError": "runtime-permission-denied",
+}
+
 
 def _append_repeated_flag(args: list[str], flag: str, values: list[str]) -> None:
     for value in values:
@@ -27,18 +37,106 @@ def _normalize_workspace(workspace: str) -> str:
     return str(Path(workspace).expanduser().resolve()) if str(workspace).strip() else ""
 
 
-def _as_tool_result(payload: dict[str, Any]) -> CallToolResult:
+def _payload_success(payload: dict[str, Any]) -> bool:
+    return bool(payload.get("success", True))
+
+
+def _runtime_error_category(payload: dict[str, Any]) -> str:
+    raw_category = str(payload.get("error_category") or payload.get("failure_category") or "").strip()
+    if raw_category:
+        return raw_category
+    returncode = payload.get("returncode")
+    if returncode is not None:
+        return "runtime-script-failed"
+    return "runtime-payload-failed"
+
+
+def _payload_error(tool_name: str, script_name: str, args: tuple[str, ...], payload: dict[str, Any]) -> dict[str, Any] | None:
+    if _payload_success(payload):
+        return None
+    summary = payload.get("summary", {}) if isinstance(payload.get("summary"), dict) else {}
+    message = str(
+        payload.get("error")
+        or summary.get("human_summary")
+        or summary.get("recommended_next_action")
+        or "Runtime script reported failure."
+    )
+    return {
+        "type": str(payload.get("error_type") or "RuntimeScriptError"),
+        "category": _runtime_error_category(payload),
+        "message": message,
+        "tool": tool_name,
+        "script": script_name,
+        "args": list(args),
+        "returncode": payload.get("returncode"),
+    }
+
+
+def _exception_category(error: Exception) -> str:
+    return EXCEPTION_ERROR_CATEGORIES.get(error.__class__.__name__, "mcp-wrapper-exception")
+
+
+def _exception_payload(tool_name: str, script_name: str, args: tuple[str, ...], error: Exception) -> tuple[dict[str, Any], dict[str, Any]]:
+    normalized_error = {
+        "type": error.__class__.__name__,
+        "category": _exception_category(error),
+        "message": str(error),
+        "tool": tool_name,
+        "script": script_name,
+        "args": list(args),
+        "returncode": None,
+    }
+    payload = {
+        "success": False,
+        "mode": "mcp-runtime-call",
+        "summary": {
+            "ready": False,
+            "human_summary": "CodeCGC MCP tool failed before a runtime JSON payload was produced.",
+            "recommended_next_action": "Check the runtime script output and MCP server logs.",
+        },
+    }
+    return payload, normalized_error
+
+
+def _build_tool_envelope(tool_name: str, payload: dict[str, Any], error: dict[str, Any] | None = None) -> dict[str, Any]:
+    success = _payload_success(payload) and error is None
+    return {
+        "success": success,
+        "tool": tool_name,
+        "payload": payload,
+        "error": error,
+        "meta": {
+            "contract_version": MCP_CONTRACT_VERSION,
+            "payload_success": _payload_success(payload),
+            "response_shape": "codecgc.mcp.tool_result",
+        },
+    }
+
+
+def _as_tool_result(tool_name: str, payload: dict[str, Any], error: dict[str, Any] | None = None) -> CallToolResult:
+    envelope = _build_tool_envelope(tool_name, payload, error)
     return CallToolResult(
         content=[
             TextContent(
                 type="text",
-                text=json.dumps(payload, ensure_ascii=True, indent=2),
+                text=json.dumps(envelope, ensure_ascii=False, indent=2),
             )
         ],
-        isError=not bool(payload.get("success", True)),
+        isError=not bool(envelope.get("success", True)),
     )
 
 
+def _call_runtime_tool(tool_name: str, script_name: str, *args: str, requested_format: str = "") -> CallToolResult:
+    try:
+        payload = run_json_script(script_name, *args)
+        if requested_format:
+            payload.setdefault("requested_format", requested_format)
+        return _as_tool_result(tool_name, payload, _payload_error(tool_name, script_name, args, payload))
+    except Exception as error:
+        payload, normalized_error = _exception_payload(tool_name, script_name, args, error)
+        return _as_tool_result(tool_name, payload, normalized_error)
+
+
 @mcp.tool(
     name="codecgc.install",
     description="Install or sync CodeCGC integration for the current project or Claude user profile.",
@@ -51,7 +149,7 @@ async def codecgc_install(
     ] = "local",
     format: Annotated[
         Literal["summary", "json"],
-        Field(description="Output format. Use summary for normal product-facing replies."),
+        Field(description="Presentation hint. MCP responses are always returned as JSON payloads."),
     ] = "summary",
     workspace: Annotated[
         str,
@@ -62,13 +160,14 @@ async def codecgc_install(
         Field(description="Optional explicit Claude user root for user/user-dry-run modes."),
     ] = "",
 ) -> CallToolResult:
-    args = ["--mode", mode, "--format", format]
+    # The MCP surface must always receive machine-readable JSON from the script.
+    args = ["--mode", mode, "--format", "json"]
     normalized_workspace = _normalize_workspace(workspace)
     if normalized_workspace:
         args.extend(["--workspace", normalized_workspace])
     if str(user_root).strip():
         args.extend(["--user-root", str(user_root).strip()])
-    return _as_tool_result(run_json_script("install_codecgc.py", *args))
+    return _call_runtime_tool("codecgc.install", "install_codecgc.py", *args, requested_format=format)
 
 
 @mcp.tool(
@@ -86,7 +185,25 @@ async def codecgc_status(
     normalized_workspace = _normalize_workspace(workspace)
     if normalized_workspace:
         args.extend(["--workspace", normalized_workspace])
-    return _as_tool_result(run_json_script("install_codecgc.py", *args))
+    return _call_runtime_tool("codecgc.status", "install_codecgc.py", *args)
+
+
+@mcp.tool(
+    name="codecgc.start",
+    description="Show the project-local CodeCGC first-run guide and recommended next actions.",
+    meta={"version": "0.1.0", "author": "CodeCGC"},
+)
+async def codecgc_start(
+    workspace: Annotated[
+        str,
+        Field(description="Optional target workspace root."),
+    ] = "",
+) -> CallToolResult:
+    args = ["--mode", "start", "--format", "json"]
+    normalized_workspace = _normalize_workspace(workspace)
+    if normalized_workspace:
+        args.extend(["--workspace", normalized_workspace])
+    return _call_runtime_tool("codecgc.start", "install_codecgc.py", *args)
 
 
 @mcp.tool(
@@ -104,7 +221,7 @@ async def codecgc_doctor(
     normalized_workspace = _normalize_workspace(workspace)
     if normalized_workspace:
         args.extend(["--workspace", normalized_workspace])
-    return _as_tool_result(run_json_script("install_codecgc.py", *args))
+    return _call_runtime_tool("codecgc.doctor", "install_codecgc.py", *args)
 
 
 @mcp.tool(
@@ -152,7 +269,7 @@ async def codecgc_entry(
         args.extend(["--audit-file", str(audit_file).strip()])
     if decision:
         args.extend(["--decision", decision])
-    return _as_tool_result(run_json_script("entry_codecgc_workflow.py", *args))
+    return _call_runtime_tool("codecgc.entry", "entry_codecgc_workflow.py", *args)
 
 
 @mcp.tool(
@@ -185,7 +302,7 @@ async def codecgc_continue(
         args.append("--auto-dispatch")
     if dry_run:
         args.append("--dry-run")
-    return _as_tool_result(run_json_script("entry_codecgc_workflow.py", *args))
+    return _call_runtime_tool("codecgc.continue", "entry_codecgc_workflow.py", *args)
 
 
 @mcp.tool(
@@ -212,7 +329,7 @@ async def codecgc_explain(
         args.append("--latest")
     if include_fixtures:
         args.append("--include-fixtures")
-    return _as_tool_result(run_json_script("entry_codecgc_workflow.py", *args))
+    return _call_runtime_tool("codecgc.explain", "entry_codecgc_workflow.py", *args)
 
 
 @mcp.tool(
@@ -236,7 +353,7 @@ async def codecgc_review(
         args.extend(["--next-step", str(next_step).strip()])
     if force:
         args.append("--force")
-    return _as_tool_result(run_json_script("review_codecgc_workflow.py", *args))
+    return _call_runtime_tool("codecgc.review", "review_codecgc_workflow.py", *args)
 
 
 @mcp.tool(
@@ -256,7 +373,7 @@ async def codecgc_history(
     args = ["--flow", flow, "--status", str(status).strip() or "all", "--last", str(int(last)), "--format", "json"]
     if include_fixtures:
         args.append("--include-fixtures")
-    return _as_tool_result(run_json_script("audit_codecgc_workflow_history.py", *args))
+    return _call_runtime_tool("codecgc.history", "audit_codecgc_workflow_history.py", *args)
 
 
 @mcp.tool(
@@ -271,7 +388,7 @@ async def codecgc_route(
     ],
     slug: Annotated[str, "Workflow slug."],
 ) -> CallToolResult:
-    return _as_tool_result(run_json_script("route_codecgc_workflow.py", "--flow", flow, "--slug", str(slug).strip()))
+    return _call_runtime_tool("codecgc.route", "route_codecgc_workflow.py", "--flow", flow, "--slug", str(slug).strip())
 
 
 @mcp.tool(
@@ -354,7 +471,7 @@ async def codecgc_plan(
     args.extend(["--artifact-class", artifact_class])
     if force:
         args.append("--force")
-    return _as_tool_result(run_json_script("plan_codecgc_workflow.py", *args))
+    return _call_runtime_tool("codecgc.plan", "plan_codecgc_workflow.py", *args)
 
 
 @mcp.tool(
@@ -385,7 +502,7 @@ async def codecgc_build(
         args.append("--dry-run")
     if return_all_messages:
         args.append("--return-all-messages")
-    return _as_tool_result(run_json_script("run_codecgc_build.py", *args))
+    return _call_runtime_tool("codecgc.build", "run_codecgc_build.py", *args)
 
 
 @mcp.tool(
@@ -416,7 +533,7 @@ async def codecgc_fix(
         args.append("--dry-run")
     if return_all_messages:
         args.append("--return-all-messages")
-    return _as_tool_result(run_json_script("run_codecgc_fix.py", *args))
+    return _call_runtime_tool("codecgc.fix", "run_codecgc_fix.py", *args)
 
 
 @mcp.tool(
@@ -451,7 +568,7 @@ async def codecgc_test(
         args.append("--dry-run")
     if return_all_messages:
         args.append("--return-all-messages")
-    return _as_tool_result(run_json_script("run_codecgc_test.py", *args))
+    return _call_runtime_tool("codecgc.test", "run_codecgc_test.py", *args)
 
 
 @mcp.tool(
@@ -465,7 +582,15 @@ async def codecgc_package_audit(
         Field(description="Output format."),
     ] = "json",
 ) -> CallToolResult:
-    return _as_tool_result(run_json_script("audit_codecgc_package_runtime.py", "--format", format))
+    return _call_runtime_tool("codecgc.package_audit", "audit_codecgc_package_runtime.py", "--format", format)
+
+
+def _external_capability_runtime_args(view: str, workspace: str, format: str) -> list[str]:
+    args = ["--view", view, "--format", format]
+    normalized_workspace = _normalize_workspace(workspace)
+    if normalized_workspace:
+        args.extend(["--workspace", normalized_workspace])
+    return args
 
 
 @mcp.tool(
@@ -480,11 +605,24 @@ async def codecgc_external_audit(
         Field(description="Output format."),
     ] = "json",
 ) -> CallToolResult:
-    args = ["--format", format]
-    normalized_workspace = _normalize_workspace(workspace)
-    if normalized_workspace:
-        args.extend(["--workspace", normalized_workspace])
-    return _as_tool_result(run_json_script("audit_codecgc_external_capabilities.py", *args))
+    args = _external_capability_runtime_args("audit", workspace, format)
+    return _call_runtime_tool("codecgc.external_audit", "audit_codecgc_external_capabilities.py", *args)
+
+
+@mcp.tool(
+    name="codecgc.external_status",
+    description="Render the concise external capability status panel for day-to-day checks.",
+    meta={"version": "0.1.0", "author": "CodeCGC"},
+)
+async def codecgc_external_status(
+    workspace: Annotated[str, "Optional target workspace root."] = "",
+    format: Annotated[
+        Literal["summary", "json"],
+        Field(description="Output format."),
+    ] = "summary",
+) -> CallToolResult:
+    args = _external_capability_runtime_args("status", workspace, format)
+    return _call_runtime_tool("codecgc.external_status", "audit_codecgc_external_capabilities.py", *args)
 
 
 @mcp.tool(
@@ -503,7 +641,7 @@ async def codecgc_release_readiness(
     normalized_workspace = _normalize_workspace(workspace)
     if normalized_workspace:
         args.extend(["--workspace", normalized_workspace])
-    return _as_tool_result(run_json_script("audit_codecgc_release_readiness.py", *args))
+    return _call_runtime_tool("codecgc.release_readiness", "audit_codecgc_release_readiness.py", *args)
 
 
 @mcp.tool(
@@ -517,7 +655,7 @@ async def codecgc_lifecycle(
         Field(description="Output format."),
     ] = "json",
 ) -> CallToolResult:
-    return _as_tool_result(run_json_script("audit_codecgc_lifecycle.py", "--format", format))
+    return _call_runtime_tool("codecgc.lifecycle", "audit_codecgc_lifecycle.py", "--format", format)
 
 
 def run() -> None:

package/model-routing.yaml

@@ -1,4 +1,17 @@
-version: 1
+version: 2
+
+orchestration_paths:
+  - "codecgc/**"
+  - ".claude/commands/**"
+  - ".claude/settings.json"
+  - ".mcp.json"
+  - "model-routing.yaml"
+
+docs_paths:
+  - "README.md"
+  - "INSTALLATION.md"
+  - "docs/**"
+  - "CHANGELOG.md"
 
 frontend_paths:
   - "apps/web/**"
@@ -9,8 +22,6 @@ frontend_paths:
   - "web/**"
   - "frontend/**"
 
-custom_frontend_paths:
-
 backend_paths:
   - "apps/api/**"
   - "server/**"
@@ -19,7 +30,19 @@ backend_paths:
   - "src/repositories/**"
   - "backend/**"
 
-custom_backend_paths:
+test_paths:
+  frontend:
+    - "apps/web/*.test.*"
+    - "apps/web/*.spec.*"
+    - "apps/web/**/*.test.*"
+    - "apps/web/**/*.spec.*"
+    - "tests/frontend/**"
+  backend:
+    - "apps/api/*.test.*"
+    - "apps/api/*.spec.*"
+    - "apps/api/**/*.test.*"
+    - "apps/api/**/*.spec.*"
+    - "tests/backend/**"
 
 shared_paths:
   - "packages/shared/**"
@@ -28,7 +51,9 @@ shared_paths:
   - "src/types/**"
 
 rules:
-  frontend_executor: "geminimcp"
+  claude_allowed_owners:
+    - "orchestration"
+    - "docs"
   backend_executor: "codexmcp"
+  frontend_executor: "geminimcp"
   shared_policy: "split-first"
-  claude_role: "plan-review-accept-only"

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@hunyed15/codecgc",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Claude-hosted multi-model workflow product shell for CodeCGC.",
   "license": "MIT",
   "type": "commonjs",
   "bin": {
     "cgc": "bin/cgc.js",
+    "cgc-start": "bin/cgc-start.js",
     "cgc-install": "bin/cgc-install.js",
     "cgc-status": "bin/cgc-status.js",
     "cgc-doctor": "bin/cgc-doctor.js",
     "cgc-package-audit": "bin/cgc-package-audit.js",
     "cgc-external-audit": "bin/cgc-external-audit.js",
+    "cgc-external-status": "bin/cgc-external-status.js",
     "cgc-release-readiness": "bin/cgc-release-readiness.js",
     "cgc-lifecycle": "bin/cgc-lifecycle.js",
     "cgc-history": "bin/cgc-history.js",
@@ -25,10 +27,12 @@
   "scripts": {
     "postinstall": "node scripts/postinstall_codecgc.js",
     "cgc:help": "node bin/cgc.js --help",
+    "cgc:start": "node bin/cgc-start.js --format summary",
     "cgc:status": "node bin/cgc-status.js --format summary",
     "cgc:doctor": "node bin/cgc-doctor.js --format summary",
     "cgc:package-audit": "node bin/cgc-package-audit.js --format summary",
     "cgc:external-audit": "node bin/cgc-external-audit.js --format summary",
+    "cgc:external-status": "node bin/cgc-external-status.js --format summary",
     "cgc:release-readiness": "node bin/cgc-release-readiness.js --format summary",
     "cgc:lifecycle": "node bin/cgc-lifecycle.js --format summary",
     "cgc:history": "node bin/cgc-history.js --status open --last 10 --format summary",
@@ -40,6 +44,7 @@
   "files": [
     "bin/",
     "scripts/*.py",
+    "scripts/codecgc_runtime/*.py",
     "scripts/postinstall_codecgc.js",
     "scripts/README-codecgc-cli.md",
     ".claude/hooks/route-edit.ps1",
@@ -56,17 +61,19 @@
     "codecgc/cgc-review/",
     "codecgc/cgc-roadmap/",
     "codecgc/cgc-test/",
+    "codecgc/compound/",
     "codecgc/reference/",
+    "codecgc/roadmap/",
     "codecgcmcp/pyproject.toml",
     "codecgcmcp/README.md",
-    "codecgcmcp/src/codecgcmcp/",
+    "codecgcmcp/src/codecgcmcp/*.py",
     "codexmcp/pyproject.toml",
     "codexmcp/README.md",
     "codexmcp/LICENSE",
-    "codexmcp/src/codexmcp/",
+    "codexmcp/src/codexmcp/*.py",
     "geminimcp/pyproject.toml",
     "geminimcp/README.md",
-    "geminimcp/src/geminimcp/",
+    "geminimcp/src/geminimcp/*.py",
     "requirements.txt",
     "INSTALLATION.md",
     "model-routing.yaml",

package/scripts/audit_codecgc_external_capabilities.py

@@ -9,6 +9,16 @@ from codecgc_runtime_paths import resolve_workspace_root
 
 WORKSPACE = Path(__file__).resolve().parents[1]
 REGISTRY_PATH = WORKSPACE / "codecgc" / "reference" / "external-capability-registry.json"
+STATUS_PANEL_CAPABILITY_ORDER = [
+    "memos",
+    "github-mcp",
+    "linear-mcp",
+    "sentry-mcp",
+]
+STATUS_PANEL_SUPPORT_CAPABILITY_ORDER = [
+    "augment-search",
+    "jira-mcp",
+]
 
 
 def load_registry() -> dict[str, Any]:
@@ -107,7 +117,7 @@ def normalize_capability_entry(entry: dict[str, Any], workspace_servers: dict[st
     }
 
 
-def audit_external_capabilities(workspace_override: str = "") -> dict[str, Any]:
+def audit_external_capabilities(workspace_override: str = "", view: str = "audit") -> dict[str, Any]:
     registry = load_registry()
     workspace_servers, workspace_root = load_workspace_mcp_servers(workspace_override)
     entries = registry.get("capabilities", [])
@@ -142,6 +152,8 @@ def audit_external_capabilities(workspace_override: str = "") -> dict[str, Any]:
         human_summary = "外部能力登记表存在缺失字段或非法项。"
     elif drift_items:
         human_summary = "外部能力登记表已就绪，但发现本地额外接入漂移。"
+    elif view == "status":
+        human_summary = "外部能力状态面板已就绪。"
 
     recommended_next_action = ""
     if blocking_items:
@@ -158,12 +170,14 @@ def audit_external_capabilities(workspace_override: str = "") -> dict[str, Any]:
     return {
         "success": ready,
         "mode": "external-capability-audit",
+        "presentation_view": view,
         "workspace": str(workspace_root),
         "registry_path": str(REGISTRY_PATH),
         "summary": {
             "ready": ready,
             "scope": "外部能力白名单、接入状态声明与本地 MCP 观测状态",
             "human_summary": human_summary,
+            "view": view,
             "capability_count": len(normalized),
             "integrated_count": counts["integrated"],
             "planned_count": counts["planned"],
@@ -178,7 +192,31 @@ def audit_external_capabilities(workspace_override: str = "") -> dict[str, Any]:
     }
 
 
-def build_summary(result: dict[str, Any]) -> str:
+def _capability_by_id(result: dict[str, Any], capability_id: str) -> dict[str, Any] | None:
+    for item in result.get("capabilities", []):
+        if not isinstance(item, dict):
+            continue
+        if str(item.get("id", "")).strip() == capability_id:
+            return item
+    return None
+
+
+def _format_capability_panel_line(item: dict[str, Any]) -> str:
+    status = str(item.get("status", "")).strip()
+    status_label = {
+        "integrated": "已纳管",
+        "planned": "规划中",
+        "optional": "可选",
+    }.get(status, status or "未知")
+    local_label = "已观测" if item.get("local_ready") else "未观测"
+    observed = ", ".join(str(value).strip() for value in item.get("observed_servers", []) if str(value).strip()) or "无"
+    return (
+        f"- {item.get('name', '')} [{item.get('id', '')}]: "
+        f"{status_label} | 本地={local_label} | 服务器={observed}"
+    )
+
+
+def build_audit_summary(result: dict[str, Any]) -> str:
     summary = result.get("summary", {}) if isinstance(result.get("summary"), dict) else {}
     lines = [
         f"- 工作区: {result.get('workspace', '')}",
@@ -249,8 +287,46 @@ def build_summary(result: dict[str, Any]) -> str:
     return render_summary_block("CodeCGC 外部能力审计", lines, next_actions)
 
 
+def build_status_panel(result: dict[str, Any]) -> str:
+    summary = result.get("summary", {}) if isinstance(result.get("summary"), dict) else {}
+    lines = [
+        f"- 工作区: {result.get('workspace', '')}",
+        f"- 登记表: {result.get('registry_path', '')}",
+        f"- 范围: {summary.get('scope', '')}",
+        f"- 摘要: {summary.get('human_summary', '')}",
+        f"- 就绪: {'是' if summary.get('ready') else '否'}",
+        f"- 正式接入: {summary.get('integrated_count', 0)}",
+        f"- 规划中: {summary.get('planned_count', 0)}",
+        f"- 可选项: {summary.get('optional_count', 0)}",
+        f"- 阻塞项: {summary.get('blocking_count', 0)}",
+        f"- 漂移项: {summary.get('drift_count', 0)}",
+        "- 正式能力面板:",
+    ]
+    for capability_id in STATUS_PANEL_CAPABILITY_ORDER:
+        item = _capability_by_id(result, capability_id)
+        if isinstance(item, dict):
+            lines.append(_format_capability_panel_line(item))
+    lines.append("- 其他受管能力:")
+    for capability_id in STATUS_PANEL_SUPPORT_CAPABILITY_ORDER:
+        item = _capability_by_id(result, capability_id)
+        if isinstance(item, dict):
+            lines.append(_format_capability_panel_line(item))
+    next_actions = []
+    next_action = str(summary.get("recommended_next_action", "")).strip()
+    if next_action:
+        next_actions.append(next_action)
+    next_actions.append("需要更细的登记一致性检查时，再跑 cgc-external-audit")
+    return render_summary_block("CodeCGC 外部能力状态面板", lines, next_actions)
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description="Audit CodeCGC external capability registry and local MCP observations.")
+    parser.add_argument(
+        "--view",
+        choices=["audit", "status"],
+        default="audit",
+        help="Rendered summary view. Audit is detailed; status is the concise panel view.",
+    )
     parser.add_argument(
         "--format",
         choices=["json", "summary"],
@@ -264,9 +340,12 @@ def main() -> int:
     )
     args = parser.parse_args()
 
-    result = audit_external_capabilities(args.workspace)
+    result = audit_external_capabilities(args.workspace, view=args.view)
     if args.format == "summary":
-        print(build_summary(result))
+        if args.view == "status":
+            print(build_status_panel(result))
+        else:
+            print(build_audit_summary(result))
     else:
         print(json.dumps(result, ensure_ascii=False, indent=2))
     return 0 if result.get("success") else 1