@hunyed15/codecgc 0.1.6 → 0.1.8

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@hunyed15/codecgc",
-  "version": "0.1.6",
+  "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

package/scripts/audit_codecgc_historical_audits.py

@@ -6,6 +6,8 @@ from typing import Any
 from codecgc_artifact_roots import discover_flow_directory
 from codecgc_artifact_roots import execution_root
 from codecgc_artifact_roots import normalize_artifact_class
+from codecgc_path_contract import is_project_relative_path
+from codecgc_path_contract import resolve_project_path
 
 
 WORKSPACE = Path(__file__).resolve().parents[1]
@@ -33,6 +35,19 @@ def contains_old_repo_name(value: Any) -> bool:
     return isinstance(value, str) and OLD_REPO_NAME in value
 
 
+def contains_persisted_absolute_project_path(value: Any) -> bool:
+    if not isinstance(value, str) or not value.strip():
+        return False
+    if is_project_relative_path(value):
+        return False
+    resolved = resolve_project_path(value)
+    try:
+        resolved.relative_to(WORKSPACE.resolve())
+        return True
+    except ValueError:
+        return False
+
+
 def expected_artifact_filename(artifact_type: str, artifact_slug: str) -> str:
     base_slug = artifact_slug[11:] if len(artifact_slug) > 11 and artifact_slug[4] == "-" else artifact_slug
     if artifact_type == "feature":
@@ -97,7 +112,7 @@ def validate_source_contract(source: dict[str, Any]) -> list[dict[str, str]]:
         )
 
     if artifact_file:
-        artifact_file_path = Path(artifact_file)
+        artifact_file_path = resolve_project_path(artifact_file)
         if not artifact_file_path.exists():
             issues.append(
                 {
@@ -105,7 +120,7 @@ def validate_source_contract(source: dict[str, Any]) -> list[dict[str, str]]:
                     "detail": artifact_file,
                 }
             )
-        elif directory not in artifact_file_path.parents:
+        elif directory.resolve() not in artifact_file_path.resolve().parents:
             issues.append(
                 {
                     "problem": "source-artifact-file-directory-mismatch",
@@ -174,6 +189,31 @@ def inspect_audit(path: Path) -> list[dict[str, str]]:
             }
         )
 
+    if contains_persisted_absolute_project_path(data.get("routing_file")):
+        issues.append(
+            {
+                "path": str(path),
+                "problem": "absolute-project-routing-file",
+                "detail": str(data.get("routing_file", "")),
+            }
+        )
+    if contains_persisted_absolute_project_path(data.get("cd")):
+        issues.append(
+            {
+                "path": str(path),
+                "problem": "absolute-project-cd",
+                "detail": str(data.get("cd", "")),
+            }
+        )
+    if contains_persisted_absolute_project_path(source.get("artifact_file")):
+        issues.append(
+            {
+                "path": str(path),
+                "problem": "absolute-project-artifact-file",
+                "detail": str(source.get("artifact_file", "")),
+            }
+        )
+
     for item in validate_source_contract(source):
         issues.append(
             {

package/scripts/audit_codecgc_package_runtime.py

@@ -13,14 +13,18 @@ PACKAGE_JSON_PATH = WORKSPACE / "package.json"
 
 RUNTIME_ENTRYPOINTS = [
     "bin/codecgc.js",
+    "bin/cgc-start.js",
+    "codecgcmcp/src/codecgcmcp/cli.py",
     "scripts/install_codecgc.py",
     "scripts/codecgc_cli.py",
+    "scripts/codecgc_policy.py",
 ]
 
 RUNTIME_STATIC_REQUIREMENTS = [
     ".claude/hooks/route-edit.ps1",
     "model-routing.yaml",
     "requirements.txt",
+    "scripts/codecgc_runtime/__init__.py",
     "scripts/audit_codecgc_external_capabilities.py",
     "scripts/audit_codecgc_lifecycle.py",
     "codexmcp/pyproject.toml",
@@ -45,10 +49,25 @@ DOC_RUNTIME_PATHS = [
     "codecgc/cgc-onboard/SKILL.md",
     "codecgc/cgc-plan/SKILL.md",
     "codecgc/cgc-review/SKILL.md",
+    "codecgc/compound/codecgc-capability-matrix.md",
+    "codecgc/reference/README.md",
     "codecgc/reference/external-capability-registry.json",
     "codecgc/reference/lifecycle-playbook.md",
+    "codecgc/reference/maintainer-guide.md",
+    "codecgc/reference/mcp-tool-surface.md",
     "codecgc/reference/operation-guide.md",
+    "codecgc/reference/path-contract.md",
+    "codecgc/reference/policy-routing.md",
+    "codecgc/reference/project-structure.md",
+    "codecgc/reference/quickstart.md",
+    "codecgc/reference/onboarding.md",
+    "codecgc/reference/recovery-loop.md",
+    "codecgc/reference/real-workflow-loop.md",
     "codecgc/reference/release-maintenance-playbook.md",
+    "codecgc/reference/troubleshooting.md",
+    "codecgc/roadmap/codecgc-release-maintenance/delivery-plan.md",
+    "codecgc/roadmap/codecgc-release-maintenance/overview.md",
+    "codecgc/roadmap/codecgc-release-maintenance/phases.md",
 ]
 
 PLACEHOLDER_METADATA_MARKERS = (
@@ -148,19 +167,64 @@ def path_matches_package_files(path_text: str, file_rules: list[str]) -> bool:
             continue
         if normalized == normalized_rule:
             return True
+        if (WORKSPACE / normalized_rule).is_dir() and normalized.startswith(f"{normalized_rule}/"):
+            return True
     return False
 
 
 def resolve_local_python_module(module_name: str) -> str:
     relative = normalize_path_text(module_name.replace(".", "/") + ".py")
-    script_candidate = f"scripts/{relative.split('/')[-1]}"
-    if (WORKSPACE / script_candidate).exists():
-        return script_candidate
+    package_candidates = [
+        f"{package}/src/{relative}"
+        for package in ("codecgcmcp", "codexmcp", "geminimcp")
+        if module_name == package or module_name.startswith(f"{package}.")
+    ]
+    candidates = [
+        *package_candidates,
+        f"scripts/{relative}",
+        f"scripts/{relative.split('/')[-1]}",
+        relative,
+    ]
+    for candidate in candidates:
+        if (WORKSPACE / candidate).exists():
+            return candidate
+    package_init = f"scripts/{normalize_path_text(module_name.replace('.', '/'))}/__init__.py"
+    if (WORKSPACE / package_init).exists():
+        return package_init
+    for package in ("codecgcmcp", "codexmcp", "geminimcp"):
+        if module_name == package or module_name.startswith(f"{package}."):
+            package_init = f"{package}/src/{normalize_path_text(module_name.replace('.', '/'))}/__init__.py"
+            if (WORKSPACE / package_init).exists():
+                return package_init
+    root_package_init = f"{normalize_path_text(module_name.replace('.', '/'))}/__init__.py"
+    if (WORKSPACE / root_package_init).exists():
+        return root_package_init
     if (WORKSPACE / relative).exists():
         return relative
     return ""
 
 
+def resolve_relative_python_module(current_path: str, level: int, module_name: str | None) -> str:
+    current = Path(normalize_path_text(current_path))
+    package_dir = current.parent
+    for _ in range(max(level - 1, 0)):
+        package_dir = package_dir.parent
+
+    if module_name:
+        candidate = package_dir / normalize_path_text(module_name.replace(".", "/") + ".py")
+        if (WORKSPACE / candidate).exists():
+            return normalize_path_text(str(candidate))
+
+        package_init = package_dir / normalize_path_text(module_name.replace(".", "/")) / "__init__.py"
+        if (WORKSPACE / package_init).exists():
+            return normalize_path_text(str(package_init))
+
+    init_candidate = package_dir / "__init__.py"
+    if (WORKSPACE / init_candidate).exists():
+        return normalize_path_text(str(init_candidate))
+    return ""
+
+
 def parse_local_python_dependencies(relative_path: str) -> tuple[list[str], list[str]]:
     path = WORKSPACE / relative_path
     tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
@@ -174,7 +238,12 @@ def parse_local_python_dependencies(relative_path: str) -> tuple[list[str], list
                 if resolved:
                     imports.append(resolved)
         elif isinstance(node, ast.ImportFrom):
-            if node.level != 0 or not node.module:
+            if node.level != 0:
+                resolved_relative = resolve_relative_python_module(relative_path, node.level, node.module)
+                if resolved_relative:
+                    imports.append(resolved_relative)
+                continue
+            if not node.module:
                 continue
             resolved = resolve_local_python_module(node.module)
             if resolved:

package/scripts/audit_codecgc_release_readiness.py

@@ -1,5 +1,7 @@
 import argparse
 import json
+import os
+import tempfile
 from pathlib import Path
 from typing import Any
 
@@ -8,14 +10,25 @@ from audit_codecgc_package_runtime import audit_package_runtime
 from codecgc_console_io import render_summary_block
 from install_codecgc import collect_doctor_status
 from install_codecgc import collect_install_status
+from install_codecgc import install_local_runtime
 
 WORKSPACE = Path(__file__).resolve().parents[1]
+RELEASE_PROBE_ROOT_ENV = "CODECGC_RELEASE_PROBE_ROOT"
 
 LIFECYCLE_REQUIRED_PATHS = [
+    "codecgc/reference/README.md",
     "codecgc/reference/lifecycle-map.md",
     "codecgc/reference/lifecycle-playbook.md",
+    "codecgc/reference/maintainer-guide.md",
+    "codecgc/reference/mcp-tool-surface.md",
     "codecgc/reference/operation-guide.md",
+    "codecgc/reference/onboarding.md",
+    "codecgc/reference/path-contract.md",
+    "codecgc/reference/quickstart.md",
+    "codecgc/reference/recovery-loop.md",
+    "codecgc/reference/real-workflow-loop.md",
     "codecgc/reference/release-maintenance-playbook.md",
+    "codecgc/reference/troubleshooting.md",
     "codecgc/reference/external-capability-registry.json",
     "codecgc/compound/codecgc-capability-matrix.md",
 ]
@@ -83,9 +96,44 @@ def collect_deploy_signals() -> dict[str, Any]:
     }
 
 
+def collect_install_probe(workspace_override: str = "") -> dict[str, Any]:
+    if str(workspace_override or "").strip():
+        install_status = collect_install_status(workspace_override)
+        doctor_status = collect_doctor_status(workspace_override)
+        return {
+            "mode": "target-workspace",
+            "workspace": str(install_status.get("workspace", "")),
+            "install_result": {},
+            "install_status": install_status,
+            "doctor_status": doctor_status,
+        }
+
+    probe_root_value = os.environ.get(RELEASE_PROBE_ROOT_ENV, "").strip()
+    probe_root = Path(probe_root_value).expanduser().resolve() if probe_root_value else None
+    if probe_root is not None:
+        probe_root.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory(
+        prefix="codecgc-release-check-",
+        dir=str(probe_root) if probe_root is not None else None,
+        ignore_cleanup_errors=True,
+    ) as temp_dir:
+        install_result = install_local_runtime(temp_dir)
+        install_status = collect_install_status(temp_dir)
+        doctor_status = collect_doctor_status(temp_dir)
+        return {
+            "mode": "temporary-project-install",
+            "workspace": temp_dir,
+            "install_result": install_result,
+            "install_status": install_status,
+            "doctor_status": doctor_status,
+        }
+
+
 def audit_release_readiness(workspace_override: str = "") -> dict[str, Any]:
-    install_status = collect_install_status(workspace_override)
-    doctor_status = collect_doctor_status(workspace_override)
+    install_probe = collect_install_probe(workspace_override)
+    install_status = install_probe["install_status"]
+    doctor_status = install_probe["doctor_status"]
     package_audit = audit_package_runtime()
     external_audit = audit_external_capabilities(workspace_override)
     lifecycle_docs = audit_document_set(LIFECYCLE_REQUIRED_PATHS)
@@ -119,12 +167,14 @@ def audit_release_readiness(workspace_override: str = "") -> dict[str, Any]:
     return {
         "success": ready,
         "mode": "release-readiness-audit",
-        "workspace": str(install_status.get("workspace", "")),
+        "workspace": str(WORKSPACE),
         "summary": {
             "ready": ready,
             "scope": "release / maintenance / ops 就绪状态",
             "human_summary": human_summary,
             "recommended_next_action": recommended_next_action,
+            "install_probe_mode": install_probe["mode"],
+            "install_probe_workspace": install_probe["workspace"],
             "install_ready": install_ready,
             "doctor_ready": doctor_ready,
             "package_ready": package_ready,
@@ -134,6 +184,7 @@ def audit_release_readiness(workspace_override: str = "") -> dict[str, Any]:
             "deploy_signals_detected": deploy_signals["deploy_signals_detected"],
             "deploy_readiness_stage": deploy_signals["deploy_readiness_stage"],
         },
+        "install_probe": install_probe,
         "install_status": install_status,
         "doctor_status": doctor_status,
         "package_audit": package_audit,
@@ -152,6 +203,7 @@ def build_summary(result: dict[str, Any]) -> str:
     lines = [
         f"- 工作区: {result.get('workspace', '')}",
         f"- 范围: {summary.get('scope', '')}",
+        f"- 安装探针: {summary.get('install_probe_mode', '')} ({summary.get('install_probe_workspace', '')})",
         f"- 就绪: {'是' if summary.get('ready') else '否'}",
         f"- 摘要: {summary.get('human_summary', '')}",
         f"- 项目级集成: {'就绪' if summary.get('install_ready') else '未就绪'}",

package/scripts/audit_codecgc_workflow_history.py

@@ -9,6 +9,8 @@ from typing import Any
 from codecgc_artifact_roots import FIXTURE_ROOT
 from codecgc_artifact_roots import PRODUCT_ROOT
 from codecgc_console_io import render_summary_block
+from codecgc_path_contract import normalize_persisted_project_path
+from codecgc_path_contract import resolve_project_path
 from codecgc_runtime_paths import PROJECT_ROOT
 from route_codecgc_workflow import attach_route_summary
 from route_codecgc_workflow import route_feature
@@ -84,7 +86,7 @@ def locate_summary_file(flow: str, directory: Path) -> str:
     matches = sorted(directory.glob(f"*{suffix}"))
     if not matches:
         return ""
-    return str(matches[0].resolve())
+    return normalize_persisted_project_path(matches[0])
 
 
 def collect_history_record(flow: str, artifact_class: str, directory: Path) -> dict[str, Any]:
@@ -97,7 +99,8 @@ def collect_history_record(flow: str, artifact_class: str, directory: Path) -> d
     audit_path = str(route.get("audit_path", "")).strip()
     audit_timestamp = ""
     if audit_path:
-        audit_time = parse_iso_like_timestamp(Path(audit_path).stat().st_mtime_ns and datetime.fromtimestamp(Path(audit_path).stat().st_mtime).isoformat())
+        resolved_audit_path = resolve_project_path(audit_path)
+        audit_time = parse_iso_like_timestamp(resolved_audit_path.stat().st_mtime_ns and datetime.fromtimestamp(resolved_audit_path.stat().st_mtime).isoformat())
         if audit_time:
             audit_timestamp = audit_time.isoformat()
 
@@ -106,7 +109,7 @@ def collect_history_record(flow: str, artifact_class: str, directory: Path) -> d
         "artifact_class": artifact_class,
         "slug": slug,
         "created": extract_created_from_slug(slug),
-        "directory": str(directory.resolve()),
+        "directory": normalize_persisted_project_path(directory),
         "workflow_state": workflow_state,
         "state_label": STATE_LABELS.get(workflow_state, workflow_state or "未知"),
         "recommended_command": str(route.get("recommended_command", "")).strip(),
@@ -116,10 +119,10 @@ def collect_history_record(flow: str, artifact_class: str, directory: Path) -> d
         "current_task_id": str(summary.get("current_task_id", "")).strip(),
         "review_decision": str(summary.get("review_decision", "")).strip(),
         "is_closed": bool(summary.get("is_closed")),
-        "audit_path": audit_path,
+        "audit_path": normalize_persisted_project_path(audit_path) if audit_path else "",
         "audit_timestamp": audit_timestamp,
         "summary_file": locate_summary_file(flow, directory),
-        "root": str(artifact_root(artifact_class).resolve()),
+        "root": normalize_persisted_project_path(artifact_root(artifact_class)),
     }
     if current_step:
         record["current_step"] = {