@hunter-harness/workflow-harness 0.2.37 → 0.2.39

package/harness/bundles/java/codebuddy/scripts/harness_review.py

@@ -19,6 +19,7 @@ import hashlib
 import json
 import os
 import re
+import subprocess
 import sys
 import uuid
 from pathlib import Path
@@ -351,43 +352,121 @@ def degradation_matrix(
     return {"fallback": "advisory", "status": "ADVISORY"}
 
 
+def _canonical_root(value: str | Path) -> str:
+    """Canonicalize a root for an identity comparison across Windows worktrees."""
+    return os.path.normcase(str(Path(value).expanduser().resolve()))
+
+
+def codegraph_worktree_id(execution_root: Path) -> str | None:
+    """Return a stable id for a linked worktree, or ``None`` for the main checkout."""
+    root = Path(execution_root).resolve()
+    try:
+        git_dir = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+        common_dir = subprocess.run(
+            ["git", "rev-parse", "--git-common-dir"],
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+        )
+    except OSError:
+        return None
+    if git_dir.returncode != 0 or common_dir.returncode != 0:
+        return None
+    git_dir_path = Path(git_dir.stdout.strip())
+    common_dir_path = Path(common_dir.stdout.strip())
+    if not git_dir_path.is_absolute():
+        git_dir_path = (root / git_dir_path).resolve()
+    if not common_dir_path.is_absolute():
+        common_dir_path = (root / common_dir_path).resolve()
+    if _canonical_root(git_dir_path) == _canonical_root(common_dir_path):
+        return None
+    return "sha256:" + hashlib.sha256(
+        _canonical_root(root).encode("utf-8")
+    ).hexdigest()
+
+
+def codegraph_expected_identity(
+    execution_root: Path,
+    *,
+    expected_repository_id: str,
+    expected_head: str,
+) -> dict[str, str | None]:
+    """Build the identity contract supplied with every CodeGraph query."""
+    root = Path(execution_root).resolve()
+    return {
+        "rootPath": str(root),
+        "worktreeId": codegraph_worktree_id(root),
+        "repositoryId": expected_repository_id,
+        "head": expected_head,
+        "indexSnapshotAt": None,
+    }
+
+
 def validate_codegraph_identity(
     *,
     response: dict[str, Any],
     expected_repository_id: str,
     expected_head: str,
+    expected_root: str | Path,
+    expected_worktree_id: str | None,
 ) -> dict[str, Any]:
-    """C12: validate CodeGraph identity — repositoryId/indexedHead must match.
+    """Validate CodeGraph evidence before Review adopts its source snippets.
 
-    On mismatch, signal CODEGRAPH_IDENTITY_MISMATCH with fallback to Grep/Glob + Read.
+    A repository id is shared by the main checkout and linked worktrees, so it
+    cannot by itself prevent main-checkout evidence from being used for feature
+    worktree review. Root and worktree identity are therefore mandatory.
     """
     repo_id = response.get("repositoryId")
-    indexed_head = response.get("indexedHead")
-    indexed_at = response.get("indexedAt")
+    indexed_head = response.get("head", response.get("indexedHead"))
+    indexed_at = response.get("indexSnapshotAt", response.get("indexedAt"))
+    root_path = response.get("rootPath", response.get("indexedRoot"))
+    worktree_id = response.get("worktreeId")
+    expected_root_path = _canonical_root(expected_root)
+    actual_root_path = (
+        _canonical_root(root_path) if isinstance(root_path, str) and root_path.strip() else None
+    )
+    actual = {
+        "rootPath": root_path,
+        "worktreeId": worktree_id,
+        "repositoryId": repo_id,
+        "head": indexed_head,
+        "indexSnapshotAt": indexed_at,
+    }
+    expected = {
+        "rootPath": str(Path(expected_root).resolve()),
+        "worktreeId": expected_worktree_id,
+        "repositoryId": expected_repository_id,
+        "head": expected_head,
+        "indexSnapshotAt": None,
+    }
     if (
         repo_id == expected_repository_id
         and indexed_head == expected_head
+        and actual_root_path == expected_root_path
+        and worktree_id == expected_worktree_id
         and indexed_at
     ):
         return {
             "ok": True,
             "code": "IDENTITY_OK",
-            "repositoryId": repo_id,
-            "indexedHead": indexed_head,
-            "indexedAt": indexed_at,
+            "evidence": actual,
         }
     return {
         "ok": False,
-        "code": "CODEGRAPH_IDENTITY_MISMATCH",
-        "expected": {
-            "repositoryId": expected_repository_id,
-            "indexedHead": expected_head,
-        },
-        "actual": {
-            "repositoryId": repo_id,
-            "indexedHead": indexed_head,
-            "indexedAt": indexed_at,
-        },
+        "code": "IDENTITY_MISMATCH",
+        "expected": expected,
+        "actual": actual,
         "fallback": "grep-glob-read",
     }
 
@@ -399,6 +478,20 @@ def cmd_validate_findings(args: argparse.Namespace) -> int:
     return _emit(payload, as_json=True)
 
 
+def cmd_validate_codegraph_identity(args: argparse.Namespace) -> int:
+    response = _read_json(Path(args.input))
+    if not isinstance(response, dict):
+        raise ValueError("CodeGraph response must be an object")
+    payload = validate_codegraph_identity(
+        response=response,
+        expected_repository_id=args.repository_id,
+        expected_head=args.head,
+        expected_root=args.execution_root,
+        expected_worktree_id=args.worktree_id,
+    )
+    return _emit(payload, as_json=True)
+
+
 def cmd_write_findings(args: argparse.Namespace) -> int:
     doc = _read_json(Path(args.input))
     return _emit(write_findings(Path(args.change_dir), doc), as_json=True)
@@ -421,6 +514,14 @@ def build_parser() -> argparse.ArgumentParser:
     p_validate.add_argument("--input", required=True)
     p_validate.set_defaults(func=cmd_validate_findings)
 
+    p_codegraph = sub.add_parser("validate-codegraph-identity")
+    p_codegraph.add_argument("--input", required=True)
+    p_codegraph.add_argument("--execution-root", required=True)
+    p_codegraph.add_argument("--repository-id", required=True)
+    p_codegraph.add_argument("--head", required=True)
+    p_codegraph.add_argument("--worktree-id")
+    p_codegraph.set_defaults(func=cmd_validate_codegraph_identity)
+
     p_findings = sub.add_parser("write-findings")
     p_findings.add_argument("--change-dir", required=True)
     p_findings.add_argument("--input", required=True)

package/harness/bundles/java/codebuddy/scripts/harness_service.py

@@ -726,6 +726,173 @@ def write_session(change_dir: Path, session: dict[str, Any]) -> Path:
     return path
 
 
+def _same_path(left: Any, right: Path | None) -> bool:
+    if right is None or not isinstance(left, str) or not left.strip():
+        return False
+    try:
+        return Path(left).resolve() == right.resolve()
+    except OSError:
+        return False
+
+
+def session_is_owned(
+    session: dict[str, Any],
+    *,
+    change_id: str | None = None,
+    execution_root: Path | None = None,
+    worktree_root: Path | None = None,
+) -> bool:
+    """Return true for an AI session owned by the supplied change/root filters.
+
+    ``change_id`` is required when provided. Root filters match if the session's
+    ``executionRoot`` or ``worktreeRoot`` equals any supplied root (OR).
+    """
+    if session.get("startedBy") != "AI":
+        return False
+    if change_id is not None and session.get("changeId") != change_id:
+        return False
+    root_matches: list[bool] = []
+    if execution_root is not None:
+        root_matches.append(_same_path(session.get("executionRoot"), execution_root))
+        root_matches.append(_same_path(session.get("worktreeRoot"), execution_root))
+    if worktree_root is not None:
+        root_matches.append(_same_path(session.get("worktreeRoot"), worktree_root))
+        root_matches.append(_same_path(session.get("executionRoot"), worktree_root))
+    if root_matches and not any(root_matches):
+        return False
+    return True
+
+
+def find_owned_sessions(
+    project_root: Path,
+    *,
+    change_id: str | None = None,
+    execution_root: Path | None = None,
+    worktree_root: Path | None = None,
+) -> dict[str, list[dict[str, Any]]]:
+    """Discover persisted sessions and classify them without stopping anything."""
+    project = resolve_path(project_root)
+    candidate_dirs: list[Path] = []
+    if change_id:
+        candidate_dirs.extend(
+            [
+                project / ".harness" / "changes" / change_id,
+                project / ".harness" / "state" / "changes" / change_id,
+            ]
+        )
+    else:
+        for root in (
+            project / ".harness" / "changes",
+            project / ".harness" / "state" / "changes",
+        ):
+            if root.is_dir():
+                candidate_dirs.extend(path for path in root.iterdir() if path.is_dir())
+
+    owned: list[dict[str, Any]] = []
+    reported: list[dict[str, Any]] = []
+    seen: set[Path] = set()
+    for change_dir in candidate_dirs:
+        path = session_path(change_dir)
+        try:
+            path = path.resolve()
+        except OSError:
+            continue
+        if path in seen or not path.is_file():
+            continue
+        seen.add(path)
+        try:
+            session = load_session(change_dir)
+        except SessionCorrupt as exc:
+            reported.append(
+                {
+                    "sessionPath": str(path),
+                    "reason": "session-corrupt",
+                    "detail": str(exc),
+                }
+            )
+            continue
+        if session is None:
+            continue
+        item = {"changeDir": str(change_dir.resolve()), "session": session}
+        if session_is_owned(
+            session,
+            change_id=change_id,
+            execution_root=execution_root,
+            worktree_root=worktree_root,
+        ):
+            owned.append(item)
+        else:
+            reported.append(
+                {
+                    "sessionPath": str(path),
+                    "reason": "not-owned",
+                    "startedBy": session.get("startedBy"),
+                    "pid": session.get("pid"),
+                    "leasedPort": session.get("leasedPort"),
+                }
+            )
+    return {"owned": owned, "reported": reported}
+
+
+def stop_owned_sessions(
+    project_root: Path,
+    *,
+    change_id: str | None = None,
+    execution_root: Path | None = None,
+    worktree_root: Path | None = None,
+) -> dict[str, Any]:
+    """Stop only discovered AI sessions whose persisted ownership still matches."""
+    discovered = find_owned_sessions(
+        project_root,
+        change_id=change_id,
+        execution_root=execution_root,
+        worktree_root=worktree_root,
+    )
+    stopped: list[dict[str, Any]] = []
+    blocked: list[dict[str, Any]] = []
+    ports_still_in_use: list[int] = []
+    for item in discovered["owned"]:
+        change_dir = Path(item["changeDir"])
+        session = item["session"]
+        if not session_is_owned(
+            session,
+            change_id=change_id,
+            execution_root=execution_root,
+            worktree_root=worktree_root,
+        ):
+            blocked.append(
+                {"sessionPath": str(session_path(change_dir)), "reason": "ownership-changed"}
+            )
+            continue
+        result = stop_ai_session(change_dir, session, require_identity=True)
+        result["sessionPath"] = str(session_path(change_dir))
+        if result.get("action") == "needs-user-decision":
+            blocked.append(result)
+            continue
+        pid = session.get("pid")
+        if isinstance(pid, int) and is_pid_alive(pid):
+            blocked.append(
+                {
+                    "sessionPath": str(session_path(change_dir)),
+                    "reason": "owned-process-still-alive",
+                    "pid": pid,
+                }
+            )
+            continue
+        stopped.append(result)
+        port = session.get("leasedPort")
+        if isinstance(port, int) and is_port_in_use(port):
+            ports_still_in_use.append(port)
+    return {
+        "ok": not blocked,
+        "ownedSessions": len(discovered["owned"]),
+        "stopped": stopped,
+        "blocked": blocked,
+        "reported": discovered["reported"],
+        "portsStillInUse": ports_still_in_use,
+    }
+
+
 # ---------------------------------------------------------------------------
 # Start / stop helpers
 # ---------------------------------------------------------------------------
@@ -924,6 +1091,10 @@ def build_session(
     command: str,
     service_start: dict[str, Any],
     started_at: str | None = None,
+    worktree_root: Path | None = None,
+    execution_root: Path | None = None,
+    change_id: str | None = None,
+    attempt_id: str | None = None,
 ) -> dict[str, Any]:
     profile_name = service_start.get("profile") or "local-dev"
     overlay = service_start.get("overlayPath") or ""
@@ -941,6 +1112,14 @@ def build_session(
     if isinstance(service_start.get("leasedPort"), int):
         session["leasedPort"] = service_start["leasedPort"]
         session["leaseOwner"] = service_start.get("leaseOwner")
+    if worktree_root is not None:
+        session["worktreeRoot"] = str(worktree_root.resolve())
+    if execution_root is not None:
+        session["executionRoot"] = str(execution_root.resolve())
+    if change_id:
+        session["changeId"] = change_id
+    if attempt_id:
+        session["attemptId"] = attempt_id
     return session
 
 
@@ -1031,6 +1210,15 @@ def cmd_ensure(args: argparse.Namespace) -> int:
     # 持久 profile 只保存模板；runtime overlay/profile 注入到 session，不写回持久 profile。
     # 含 worktree/change 陈旧持久值时拒绝（修复输入端陈旧 profile）。
     change_name = getattr(args, "change_name", None) or change_dir.name
+    worktree_root_raw = getattr(args, "worktree_root", None)
+    execution_root_raw = getattr(args, "execution_root", None)
+    attempt_id = str(getattr(args, "attempt_id", None) or "").strip() or None
+    worktree_root = (
+        resolve_path(worktree_root_raw) if worktree_root_raw else project
+    )
+    execution_root = (
+        resolve_path(execution_root_raw) if execution_root_raw else None
+    )
     overlay = getattr(args, "overlay", None)
     leased_port = getattr(args, "leased_port", None)
     lease_owner = str(getattr(args, "lease_owner", None) or "").strip() or None
@@ -1135,6 +1323,10 @@ def cmd_ensure(args: argparse.Namespace) -> int:
                 as_json=as_json,
                 action="restarted",
                 previousPid=pid,
+                worktree_root=worktree_root,
+                execution_root=execution_root,
+                change_id=change_name,
+                attempt_id=attempt_id,
             )
 
         # pid dead → stale session; clear and fall through
@@ -1161,6 +1353,10 @@ def cmd_ensure(args: argparse.Namespace) -> int:
         files=files,
         as_json=as_json,
         action="started",
+        worktree_root=worktree_root,
+        execution_root=execution_root,
+        change_id=change_name,
+        attempt_id=attempt_id,
     )
 
 
@@ -1173,6 +1369,10 @@ def _start_and_record(
     files: list[str],
     as_json: bool,
     action: str,
+    worktree_root: Path | None = None,
+    execution_root: Path | None = None,
+    change_id: str | None = None,
+    attempt_id: str | None = None,
     **extra: Any,
 ) -> int:
     if not files:
@@ -1224,6 +1424,10 @@ def _start_and_record(
         command=command,
         service_start=service_start,
         started_at=started_at,
+        worktree_root=worktree_root,
+        execution_root=execution_root,
+        change_id=change_id,
+        attempt_id=attempt_id,
     )
     write_session(change_dir, session)
 
@@ -1423,6 +1627,21 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="run id that owns --leased-port",
     )
+    p_ensure.add_argument(
+        "--worktree-root",
+        default=None,
+        help="worktree that owns the service (default: --project)",
+    )
+    p_ensure.add_argument(
+        "--execution-root",
+        default=None,
+        help="ephemeral execution worktree that owns the service",
+    )
+    p_ensure.add_argument(
+        "--attempt-id",
+        default=None,
+        help="phase or transaction attempt that started the service",
+    )
     p_ensure.add_argument("--json", action="store_true")
     p_ensure.set_defaults(func=cmd_ensure)
 

package/harness/bundles/java/codex/.harness-build.json

@@ -2,5 +2,5 @@
   "schemaVersion": 1,
   "overlay": "java",
   "agent": "codex",
-  "coreHash": "ba5709391ecbe88b"
+  "coreHash": "339633bdc97d2146"
 }

package/harness/bundles/java/codex/harness-apidoc/SKILL.md

@@ -2,7 +2,7 @@
 name: harness-apidoc
 description: 从 Java 后端代码生成结构化前端 API 文档（Controller/VO/ErrorCode）。使用场景：接口文档、前端接口文档、API 文档生成
 ---
-<!-- generated by harness_deploy.py; core=ba5709391ecbe88b; overlay=java; agent=codex; do not edit -->
+<!-- generated by harness_deploy.py; core=339633bdc97d2146; overlay=java; agent=codex; do not edit -->
 # harness-apidoc — 前端接口文档（Java overlay）
 
 ## Purpose

package/harness/bundles/java/codex/harness-archive/SKILL.md

@@ -3,7 +3,7 @@ name: harness-archive
 description: 归档所有变更产出（计划/测试报告/审查/SQL/API文档）到
   .harness/archive/，含归档元数据和可视化最终总结。使用场景：归档、完成归档、收尾、打包产出物
 ---
-<!-- generated by harness_deploy.py; core=ba5709391ecbe88b; overlay=java; agent=codex; do not edit -->
+<!-- generated by harness_deploy.py; core=339633bdc97d2146; overlay=java; agent=codex; do not edit -->
 # harness-archive — 变更归档
 
 ## Purpose
@@ -26,7 +26,7 @@ description: 归档所有变更产出（计划/测试报告/审查/SQL/API文档
 自动调用边界：
 
 - 归档涉及移动/删除原变更目录，支持被其他 skill 调用，但调用前必须确保前置条件已满足；也支持用户显式 `/harness-archive` 调用。
-- 归档前确认是强制阻断检查点，用户拒绝 → 终止流程，不执行任何操作。
+- 默认归档前确认是阻断检查点。若 `harness_archive.py auto-gate` 返回 `ARCHIVE_AUTO_GATE_SATISFIED`（Submit 或 Merge 已终态，archive-boundary snapshot 存在且全部归档门禁满足），后续 Archive 可无 AskQuestion 自动运行；其他情况仍须确认。
 
 ## 前置条件
 
@@ -89,9 +89,12 @@ description: 归档所有变更产出（计划/测试报告/审查/SQL/API文档
 - **Read `checklist.md`** — 归档前检查项
 - 发现多个未归档变更 → 让用户选择或终止
 
-### Phase 2：确认归档 ⚠️ 强制阻断
+### Phase 2：确认归档 / 自动门禁
 
-blocking user confirmation 让用户确认归档操作。**用户拒绝 → 终止流程，不执行任何操作。**
+先运行 `harness_archive.py auto-gate --change-dir ".harness/changes/<change-name>" --intent <intent> --json`。
+
+- `autoArchiveAllowed=true`：记录 gate receipt，直接进入 Phase 3；无需 AskQuestion。
+- 否则：blocking user confirmation 让用户确认归档操作。**用户拒绝 → 终止流程，不执行任何操作。**
 
 - **Read `reference.md`** — 确认对话框的内容格式
 
@@ -126,9 +129,9 @@ blocking user confirmation 让用户确认归档操作。**用户拒绝 → 终
 
 扫描排除 `.harness/archive/`；多个未归档变更 → 让用户选择或终止，不批量归档。
 
-### 二、归档前确认是强制阻断检查点
+### 二、归档前确认或自动门禁
 
-blocking user confirmation 确认；用户拒绝 → 终止，不执行任何操作。
+`auto-gate` 只有在 Submit/Merge 终态、`meta/state-snapshot.json` 含 archive-boundary base、且 `status.archivable=true` 时才允许无确认执行。未满足时 blocking user confirmation；用户拒绝 → 终止，不执行任何操作。
 
 ### 三、文件移动只用内置工具或 PowerShell
 
@@ -201,7 +204,7 @@ git 命令通过 `powershell.exe -Command "..."` 执行；archive-meta.md 和 fi
 
 ## 交互白名单
 
-**仅允许**归档确认（Phase 2 blocking user confirmation）；拒绝 → 终止，不执行任何移动。
+仅当 `auto-gate` 未满足时，允许归档确认（Phase 2 blocking user confirmation）；拒绝 → 终止，不执行任何移动。
 
 ## 执行日志
 

package/harness/bundles/java/codex/harness-archive/templates/render-summary.mjs

@@ -69,7 +69,7 @@ const risks = list(current.findings).length
 const statusTone = (raw) => {
   const status = String(raw || "UNKNOWN").toUpperCase();
   if (/FAIL|ERROR|BLOCKED/.test(status)) return "danger";
-  if (/WARN|CONDITIONAL|PARTIAL|NOT_RUN|UNKNOWN|SKIP/.test(status)) return "warning";
+  if (/WARN|CONDITIONAL|PARTIAL|NOT_RUN|UNKNOWN|SKIP|EVIDENCE_MISSING/.test(status)) return "warning";
   if (/ADVISORY|REUSED|NOT_APPLICABLE/.test(status)) return "neutral";
   return "success";
 };
@@ -77,7 +77,7 @@ const STATUS_LABELS = {
   OK: "通过", PASS: "通过", PASSED: "通过", CONDITIONAL_OK: "有条件通过",
   WARN: "警告", ADVISORY: "建议", FAIL: "失败", FAILED: "失败", ERROR: "错误",
   BLOCKED: "阻塞", NOT_RUN: "未运行", SKIPPED: "已跳过",
-  NOT_APPLICABLE: "不适用", UNKNOWN: "未知"
+  NOT_APPLICABLE: "不适用", UNKNOWN: "未知", EVIDENCE_MISSING: "证据缺失"
 };
 const pill = (raw) => {
   const status = String(raw || "UNKNOWN").toUpperCase();
@@ -115,7 +115,17 @@ const verificationStatus = (value) => {
 };
 const verificationNote = (key, raw) => {
   const value = record(raw);
-  if (key === "unitTests") return `${value.passRate || `${value.run ?? 0} 项`} · 失败 ${value.failures ?? 0}`;
+  if (key === "unitTests") {
+    const unique = numeric(value.uniqueTestCount);
+    const uniqueLabel = unique === null ? "唯一用例未记录" : `唯一 ${unique} 项`;
+    return `${value.passRate || `${value.run ?? 0} 次执行`} · ${uniqueLabel} · 重跑 ${value.rerunCount ?? 0}`;
+  }
+  if (key === "dbCompatibility") {
+    const evidence = record(verification.dbCompatibilityEvidence);
+    return evidence.status === "EVIDENCE_MISSING"
+      ? "缺少可验证的类型化账本/收据"
+      : evidence.reason || evidence.evidenceHash || "类型化兼容性证据";
+  }
   if (key === "apiTests") return `${value.passRate || `${value.passed ?? 0}/${value.total ?? 0}`} · 阻塞 ${value.blocked ?? 0}`;
   if (key === "browserE2E") return `${value.passed ?? 0}/${value.total ?? 0} 通过 · ${value.failed ?? 0} 失败 · 重试 ${value.retries ?? 0}`;
   if (value.checks !== undefined) return `${value.checks} 项检查`;
@@ -135,6 +145,8 @@ const groups = [
   const statuses = values.map(verificationStatus);
   const groupStatus = statuses.some((status) => /FAIL|ERROR|BLOCKED/.test(String(status)))
     ? "FAIL"
+    : statuses.some((status) => /EVIDENCE_MISSING/.test(String(status)))
+    ? "EVIDENCE_MISSING"
     : statuses.some((status) => /WARN|CONDITIONAL|PARTIAL/.test(String(status)))
     ? "WARN"
     : statuses.length && statuses.every((status) => /NOT_APPLICABLE/.test(String(status)))
@@ -147,6 +159,13 @@ const groups = [
 });
 const passedGroups = groups.filter((group) => group.status === "OK").length;
 const productCommit = identity.productCommit || data.productCommit || data.finalCommit;
+const identityChain = [
+  ["检查点", identity.checkpointCommit || data.checkpointCommit],
+  ["产品", productCommit],
+  ["功能尖端", identity.featureTip || data.featureTip],
+  ["合并", identity.mergeCommit || data.mergeCommit || identity.featureMergeHash],
+  ["发布尖端", identity.releaseTip || data.releaseTip || identity.releaseTipHash]
+].filter(([, value]) => value).map(([label, value]) => `${label} ${shortHash(value)}`).join(" → ") || "N/A";
 const wallClock = timing.workflowWallClockMs ?? record(data.durations).totalMs;
 
 const groupHtml = groups.map((group) => `
@@ -201,7 +220,7 @@ const html = `<!doctype html>
   ${recordOnly ? '<div class="record-only">归档意图：仅记录 · 未请求发布</div>' : ""}
 </section>
 <section class="metrics">
-  <article class="metric"><small>产品提交</small><strong><code title="${esc(productCommit || "N/A")}">${esc(shortHash(productCommit))}</code></strong></article>
+  <article class="metric"><small>产品提交链</small><strong><code title="${esc(identityChain)}">${esc(identityChain)}</code></strong></article>
   <article class="metric"><small>验证概览</small><strong>${passedGroups}/${groups.length} 组通过</strong><small>按后端 / Geo / 前端 / 浏览器 / API</small></article>
   <article class="metric"><small>风险与动作</small><strong>${risks.length} / ${actions.length}</strong><small>当前风险 / 人工动作</small></article>
   <article class="metric"><small>全流程耗时</small><strong>${esc(duration(wallClock))}</strong><small>活动 ${esc(duration(timing.stageActiveExecutionMs))}</small></article>
@@ -234,6 +253,7 @@ const html = `<!doctype html>
 <details><summary>命令证据（${commands.length}）</summary><div class="table-wrap"><table><thead><tr><th>阶段</th><th>命令</th><th>结果</th></tr></thead><tbody>${commandHtml}</tbody></table></div></details>
 <details><summary>技术元数据</summary><div><dl>
   <dt>产品提交</dt><dd><code>${esc(productCommit || "N/A")}</code></dd>
+  <dt>检查点 → 产品 → 功能尖端 → 合并 → 发布尖端</dt><dd><code>${esc(identityChain)}</code></dd>
   <dt>产品树哈希</dt><dd><code>${esc(identity.productTreeHash || data.productTreeHash || "N/A")}</code></dd>
   <dt>环境哈希</dt><dd><code>${esc(identity.environmentHash || data.environmentHash || "N/A")}</code></dd>
   <dt>基线提交</dt><dd><code>${esc(identity.baseCommit || data.baseCommit || "N/A")}</code></dd>

package/harness/bundles/java/codex/harness-codebase-map/SKILL.md

@@ -3,7 +3,7 @@ name: harness-codebase-map
 description: 分析现有代码库并生成 .harness/codebase/map/
   下的结构化代码库地图。用于陌生项目理解、重大改造前梳理、harness-sync 提示 map 过期后的人工刷新。
 ---
-<!-- generated by harness_deploy.py; core=ba5709391ecbe88b; overlay=java; agent=codex; do not edit -->
+<!-- generated by harness_deploy.py; core=339633bdc97d2146; overlay=java; agent=codex; do not edit -->
 # harness-codebase-map — 代码库地图
 
 ## Purpose

package/harness/bundles/java/codex/harness-knowledge-ingest/SKILL.md

@@ -3,7 +3,7 @@ name: harness-knowledge-ingest
 description: 从 .harness/archive 归档整理、同步和维护项目知识索引。适用场景：ingest knowledge、sync
   knowledge、rebuild knowledge index、promote knowledge、确认知识条目、检查知识库是否过期。
 ---
-<!-- generated by harness_deploy.py; core=ba5709391ecbe88b; overlay=java; agent=codex; do not edit -->
+<!-- generated by harness_deploy.py; core=339633bdc97d2146; overlay=java; agent=codex; do not edit -->
 # harness-knowledge-ingest
 
 从 `.harness/archive/**/reports/final/summary-data.json` 抽取项目知识，生成并维护本地 `.harness/knowledge/` 索引。