@hunter-harness/workflow-harness 0.3.1 → 0.4.1

package/harness/bundles/general/codex/scripts/harness_knowledge_candidates.py

@@ -2,17 +2,21 @@
 """Knowledge candidate generation from an archived change's summary-data.json.
 
 The archive workflow has already filtered once: review findings were produced by
-an independent reviewer and then adjudicated, and knownRisks are evidence-derived
-facts. This module turns those two — and only those two — into KnowledgeCandidate
-records for the archive package's ``candidates/knowledge.json``.
+an independent reviewer and then adjudicated, knownRisks are evidence-derived
+facts, and decisions are structured records adopted upstream (plan/execute/
+review). This module turns those three — and only those three — into
+KnowledgeCandidate records for the archive package's ``candidates/knowledge.json``.
 
 Mapping is fixed by docs/superpowers/specs/2026-08-18-three-views-data-flow-design.md
-("知识来源的选定")::
+("知识来源的选定"), extended 2026-08-23 with the decisions source::
 
     disposition = FIXED                      -> pitfall   RED 0.95 / YELLOW 0.85
     disposition = ACCEPTED_RISK | DEFERRED   -> risk      RED 0.95 / YELLOW 0.85
     knownRisks[]                             -> risk      0.85
+    decisions[status=adopted]                -> record's entry_type (decision |
+                                                requirement | api-contract)  0.85
     severity = OK | disposition = NOT_APPLICABLE -> dropped
+    decisions[status != adopted]             -> kept in summary, not knowledge
 
 Dispositions outside the adopted set (OPEN / UNKNOWN) are dropped too: an
 unadjudicated finding is not yet knowledge. maintenanceNotes, finalStatusReasons
@@ -42,6 +46,16 @@ _DISPOSITION_ENTRY_TYPES = {
 _SEVERITY_CONFIDENCE = {"RED": 0.95, "YELLOW": 0.85}
 _KNOWN_RISK_CONFIDENCE = 0.85
 
+# decisions[]（来自 change 的 evidence/decisions.json，经 summary.decisions 传入）
+# 与 findings 的裁决门槛同源：只有已采纳（adopted）的决策才成为候选——
+# proposed/rejected/superseded 留在 summary 里做记录，但不构成知识。
+# entry_type 直接取自记录，取值与 knowledgeCandidateEntryTypeSchema 对齐；
+# source 对应 candidateProvenanceSourceKindSchema 的枚举。
+_DECISION_ENTRY_TYPES = {"decision", "requirement", "api-contract"}
+_DECISION_STATUSES = {"adopted", "proposed", "rejected", "superseded"}
+_DECISION_SOURCE_KINDS = {"plan", "review", "manual", "archive"}
+_DECISION_CONFIDENCE = 0.85
+
 _MAX_KEYWORDS = 32
 _MAX_KEYWORD_CHARS = 80
 _MAX_BODY_CHARS = 20_000
@@ -204,6 +218,86 @@ def _risk_candidate(
     }
 
 
+def _decision_candidate(
+    record: dict[str, Any],
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> dict[str, Any] | None:
+    """Project one adopted design decision / requirement / API contract entry.
+
+    Every field is copied from the record (written upstream by a human or an
+    agent during plan/execute/review); nothing is inferred at archive time.
+    """
+    title = _text(record.get("title"))
+    entry_type = _text(record.get("entry_type"))
+    status = _text(record.get("status")).lower()
+    if not title or entry_type not in _DECISION_ENTRY_TYPES or status != "adopted":
+        return None
+
+    rationale = _text(record.get("rationale"))
+    path = _text(record.get("path"))
+    line = record.get("line")
+    location = _location(path, line)
+    segments = _path_segments(path)
+    record_id = _text(record.get("id"))
+    source = _text(record.get("source"))
+    if source not in _DECISION_SOURCE_KINDS:
+        source = "plan"
+    raw_keywords = record.get("keywords")
+    record_keywords = (
+        [item for item in raw_keywords if isinstance(item, str)]
+        if isinstance(raw_keywords, list)
+        else []
+    )
+
+    body_lines = [title]
+    if rationale:
+        body_lines.append(f"理由：{rationale}")
+    if location:
+        body_lines.append(f"位置：{location}")
+    body_lines.append(f"类型：{entry_type}")
+    body = "\n".join(body_lines)[:_MAX_BODY_CHARS]
+    keywords = _keywords(
+        *record_keywords,
+        segments[-1] if segments else "",
+        segments[-2] if len(segments) >= 2 else "",
+        entry_type,
+    )
+    if path and location != path:
+        source_refs = [f"{path}#L{line}"]
+    elif path:
+        source_refs = [path]
+    else:
+        source_refs = [f"archive:{archive_id}"]
+
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "candidate_id": _candidate_id(
+            change_key, "decision", record_id or f"{title}\0{path}\0{line}"
+        ),
+        "source_change_key": change_key,
+        "source_refs": source_refs,
+        "summary": title,
+        "reusability_scope": segments[0] if segments else "project",
+        "content_hash": _content_hash(entry_type, title, body, keywords),
+        "confidence": _DECISION_CONFIDENCE,
+        "status": "pending",
+        "entry_type": entry_type,
+        "body": body,
+        "keywords": keywords,
+        "provenance": {
+            "source_kind": source,
+            "source_ref": f"archive:{archive_id}#{record_id}" if record_id else f"archive:{archive_id}",
+            "producer": PRODUCER,
+            "producer_version": producer_version,
+            "created_at": created_at,
+        },
+    }
+
+
 def build_knowledge_candidates(
     summary: dict[str, Any],
     *,
@@ -252,6 +346,446 @@ def build_knowledge_candidates(
                     created_at=created_at,
                 ))
 
+    decisions = summary.get("decisions")
+    if isinstance(decisions, list):
+        for record in decisions:
+            if isinstance(record, dict):
+                collect(_decision_candidate(
+                    record,
+                    change_key=change_key,
+                    archive_id=archive_id,
+                    producer_version=producer_version,
+                    created_at=created_at,
+                ))
+
+    return candidates
+
+
+# Dispositions that mean "not yet adjudicated". A finding in this state with a
+# knowledge-carrying severity is dropped by the mapping above — correctly — but
+# the drop must be visible, or an archive with real findings looks identical to
+# an archive with nothing worth keeping (both ship an empty candidates file).
+_UNADJUDICATED_DISPOSITIONS = {"", "OPEN", "UNKNOWN"}
+
+
+def count_unadjudicated_findings(summary: dict[str, Any]) -> int:
+    """Count RED/YELLOW reviewFindings whose disposition is not yet adjudicated.
+
+    These are the findings the mapping table silently drops. Callers use the
+    count to warn when an archive would otherwise show "ready / 0 results"
+    despite carrying real, unprocessed review signal.
+    """
+    if not isinstance(summary, dict):
+        return 0
+    findings = summary.get("reviewFindings")
+    if not isinstance(findings, list):
+        return 0
+    count = 0
+    for finding in findings:
+        if not isinstance(finding, dict):
+            continue
+        severity = _text(finding.get("severity"))
+        disposition = _text(finding.get("disposition")).upper()
+        if severity in _SEVERITIES and disposition in _UNADJUDICATED_DISPOSITIONS:
+            count += 1
+    return count
+
+
+# --- plan/design-derived knowledge candidates ---------------------------------
+#
+# reviewFindings/knownRisks/decisions 只覆盖“经对抗评审的变更”。没有评审的简单
+# 变更（无 RED/YELLOW 发现、无 knownRisks、无 adopted decisions）仍产出了
+# 经用户确认批准的 design/plan/test-scenarios——这些也是值得沉淀的知识。
+# 这里把 plans/*.md（v2 finalize 派生的机器契约）解析回结构化的自然内容，
+# 与 summary 三源并列，但 confidence 略低（机器派生而非独立评审）。
+
+_PLAN_CONFIDENCE = 0.85
+_PLAN_SOURCE_KIND = "plan"
+
+
+def _unescape_markdown(value: str) -> str:
+    """Reverse the renderer's markdown escaping for clean knowledge text.
+
+    harness-plan finalize 的渲染器对自由文本做了反斜杠/实体转义。知识候选存
+    的是自然语言，不需要保留渲染转义。顺序有讲究：先反转义实体，再反转义
+    反斜杠序列（从长到短）。
+    """
+    value = (
+        value.replace("&lt;", "<")
+        .replace("&gt;", ">")
+        .replace("&amp;", "&")
+        .replace("<br>", "\n")
+    )
+    return (
+        value.replace("\\`", "`")
+        .replace("\\#", "#")
+        .replace("\\*", "*")
+        .replace("\\[", "[")
+        .replace("\\]", "]")
+        .replace("\\\\", "\\")
+    )
+
+
+def _markdown_sections(text: str) -> dict[str, list[str]]:
+    """Split a v2 rendered markdown artifact into its ``## Header`` sections.
+
+    Returns ``{header: [lines...]}``. Only the ``##`` level is split; ``###``
+    and ``####`` content stays inside its parent section's lines.
+    """
+    sections: dict[str, list[str]] = {}
+    current: str | None = None
+    for line in text.splitlines():
+        if line.startswith("## ") and not line.startswith("### "):
+            current = line[3:].strip()
+            sections[current] = []
+        elif current is not None:
+            sections[current].append(line)
+    return sections
+
+
+def _plan_source_refs(change_key: str, package_path: str) -> list[str]:
+    """source_refs must exist in the package (core-v1 containment check)."""
+    return [package_path]
+
+
+def _plan_candidate(
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+    kind: str,
+    entry_type: str,
+    summary: str,
+    body: str,
+    keywords: list[str],
+    source_refs: list[str],
+    reusability_scope: str = "project",
+) -> dict[str, Any]:
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "candidate_id": _candidate_id(change_key, kind, summary),
+        "source_change_key": change_key,
+        "source_refs": source_refs,
+        "summary": summary,
+        "reusability_scope": reusability_scope,
+        "content_hash": _content_hash(entry_type, summary, body, keywords),
+        "confidence": _PLAN_CONFIDENCE,
+        "status": "pending",
+        "entry_type": entry_type,
+        "body": body,
+        "keywords": keywords,
+        "provenance": {
+            "source_kind": _PLAN_SOURCE_KIND,
+            "source_ref": f"archive:{archive_id}",
+            "producer": PRODUCER,
+            "producer_version": producer_version,
+            "created_at": created_at,
+        },
+    }
+
+
+def _requirements_from_design(
+    design_text: str,
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> list[dict[str, Any]]:
+    """Parse ``## Requirements`` from design.md into requirement candidates.
+
+    Each line is ``- requirement:sha256:... [kind]: text`` where kind is
+    behavior | invariant | failure_behavior.
+    """
+    sections = _markdown_sections(design_text)
+    lines = sections.get("Requirements", [])
+    out: list[dict[str, Any]] = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped.startswith("- "):
+            continue
+        prefix = stripped[2:]
+        # kind 位于第一个 `]: ` 之前的方括号内。
+        close_bracket = prefix.find("]")
+        if close_bracket <= 0 or not prefix.startswith("requirement:"):
+            continue
+        kind = prefix[1:close_bracket].strip()
+        if kind not in {"behavior", "invariant", "failure_behavior"}:
+            continue
+        colon = prefix.find(": ", close_bracket + 1)
+        if colon == -1:
+            continue
+        text = _unescape_markdown(prefix[colon + 2:].strip())
+        if not text:
+            continue
+        entry_type = "requirement"
+        body = f"需求类型：{kind}\n{text}"
+        keywords = _keywords(kind, entry_type)
+        out.append(_plan_candidate(
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+            kind="requirement",
+            entry_type=entry_type,
+            summary=text,
+            body=body,
+            keywords=keywords,
+            source_refs=_plan_source_refs(change_key, f"plans/{change_key}-design.md"),
+        ))
+    return out
+
+
+def _risks_from_design(
+    design_text: str,
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> list[dict[str, Any]]:
+    """Parse ``## Risks`` (``- risk`` + ``  - Mitigation: ...``) into risk candidates."""
+    sections = _markdown_sections(design_text)
+    lines = sections.get("Risks", [])
+    out: list[dict[str, Any]] = []
+    index = 0
+    while index < len(lines):
+        stripped = lines[index].strip()
+        if not stripped.startswith("- "):
+            index += 1
+            continue
+        risk = _unescape_markdown(stripped[2:].strip())
+        if not risk or risk == "None.":
+            index += 1
+            continue
+        mitigation = ""
+        if index + 1 < len(lines) and lines[index + 1].strip().startswith("- Mitigation:"):
+            mitigation = _unescape_markdown(
+                lines[index + 1].strip()[len("- Mitigation:"):].strip()
+            )
+            index += 1
+        body = risk if not mitigation else f"{risk}\n缓解：{mitigation}"
+        out.append(_plan_candidate(
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+            kind="risk",
+            entry_type="risk",
+            summary=risk,
+            body=body,
+            keywords=_keywords("risk"),
+            source_refs=_plan_source_refs(change_key, f"plans/{change_key}-design.md"),
+        ))
+        index += 1
+    return out
+
+
+def _invariants_from_design(
+    design_text: str,
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> list[dict[str, Any]]:
+    """Parse ``## Invariants`` bullet list into requirement candidates."""
+    sections = _markdown_sections(design_text)
+    out: list[dict[str, Any]] = []
+    for line in sections.get("Invariants", []):
+        stripped = line.strip()
+        if not stripped.startswith("- "):
+            continue
+        text = _unescape_markdown(stripped[2:].strip())
+        if not text or text == "None.":
+            continue
+        out.append(_plan_candidate(
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+            kind="invariant",
+            entry_type="requirement",
+            summary=text,
+            body=f"需求类型：invariant\n{text}",
+            keywords=_keywords("invariant", "requirement"),
+            source_refs=_plan_source_refs(change_key, f"plans/{change_key}-design.md"),
+        ))
+    return out
+
+
+def _tasks_from_plan(
+    plan_text: str,
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> list[dict[str, Any]]:
+    """Parse ``## Tasks`` from plan.md into implementation candidates.
+
+    Task headings are ``### T1``; the objective is the non-empty text between
+    the heading and the first ``- `` metadata bullet.
+    """
+    sections = _markdown_sections(plan_text)
+    lines = sections.get("Tasks", [])
+    out: list[dict[str, Any]] = []
+    index = 0
+    while index < len(lines):
+        stripped = lines[index].strip()
+        if not stripped.startswith("### "):
+            index += 1
+            continue
+        task_id = stripped[4:].strip()
+        index += 1
+        objective_parts: list[str] = []
+        while index < len(lines):
+            current = lines[index].strip()
+            if current.startswith("### ") or current.startswith("- "):
+                break
+            if current:
+                objective_parts.append(current)
+            index += 1
+        objective = " ".join(objective_parts).strip()
+        if not objective:
+            continue
+        body = f"任务：{task_id}\n{objective}"
+        out.append(_plan_candidate(
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+            kind="task",
+            entry_type="implementation",
+            summary=objective,
+            body=body,
+            keywords=_keywords(task_id, "implementation"),
+            source_refs=_plan_source_refs(change_key, f"plans/{change_key}-plan.md"),
+        ))
+    return out
+
+
+def _scenarios_from_test_scenarios(
+    scenarios_text: str,
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> list[dict[str, Any]]:
+    """Parse ``## <id>: <title>`` headings into test-evidence candidates."""
+    out: list[dict[str, Any]] = []
+    for line in scenarios_text.splitlines():
+        stripped = line.strip()
+        if not stripped.startswith("## ") or stripped.startswith("### "):
+            continue
+        heading = stripped[3:].strip()
+        if heading == "Coverage":
+            continue
+        if ":" not in heading:
+            continue
+        scenario_id, title = heading.split(":", 1)
+        title = title.strip()
+        if not title:
+            continue
+        out.append(_plan_candidate(
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+            kind="scenario",
+            entry_type="test-evidence",
+            summary=title,
+            body=f"场景：{scenario_id.strip()}\n{title}",
+            keywords=_keywords(scenario_id.strip(), "test-evidence"),
+            source_refs=_plan_source_refs(
+                change_key, f"plans/{change_key}-test-scenarios.md"
+            ),
+        ))
+    return out
+
+
+def build_plan_candidates(
+    archive_dir,
+    *,
+    change_key: str,
+    archive_id: str,
+    producer_version: str,
+    created_at: str,
+) -> list[dict[str, Any]]:
+    """Extract knowledge candidates from the archive's plans/*.md artifacts.
+
+    Complements ``build_knowledge_candidates`` (summary 三源)。没有评审的简单
+    变更仍然产出 plans/*.md；这些是经用户确认批准的结构化真相源，parse 回来
+    就是可沉淀的知识。缺文件/解析失败返回 []（软失败）。
+    """
+    candidates: list[dict[str, Any]] = []
+    seen_ids: set[str] = set()
+
+    def collect(items: list[dict[str, Any]]) -> None:
+        for candidate in items:
+            if candidate["candidate_id"] in seen_ids:
+                continue
+            seen_ids.add(candidate["candidate_id"])
+            candidates.append(candidate)
+
+    design_path = archive_dir / "plans" / f"{change_key}-design.md"
+    if design_path.is_file():
+        try:
+            design_text = design_path.read_text(encoding="utf-8-sig")
+        except OSError:
+            design_text = ""
+        collect(_requirements_from_design(
+            design_text,
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+        ))
+        collect(_risks_from_design(
+            design_text,
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+        ))
+        collect(_invariants_from_design(
+            design_text,
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+        ))
+
+    plan_path = archive_dir / "plans" / f"{change_key}-plan.md"
+    if plan_path.is_file():
+        try:
+            plan_text = plan_path.read_text(encoding="utf-8-sig")
+        except OSError:
+            plan_text = ""
+        collect(_tasks_from_plan(
+            plan_text,
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+        ))
+
+    scenarios_path = archive_dir / "plans" / f"{change_key}-test-scenarios.md"
+    if scenarios_path.is_file():
+        try:
+            scenarios_text = scenarios_path.read_text(encoding="utf-8-sig")
+        except OSError:
+            scenarios_text = ""
+        collect(_scenarios_from_test_scenarios(
+            scenarios_text,
+            change_key=change_key,
+            archive_id=archive_id,
+            producer_version=producer_version,
+            created_at=created_at,
+        ))
+
     return candidates
 
 

package/harness/bundles/general/cursor/.harness-build.json

@@ -2,5 +2,5 @@
   "schemaVersion": 1,
   "overlay": "none",
   "agent": "cursor",
-  "coreHash": "b246bb49cee55535"
+  "coreHash": "041ded3368e8c2df"
 }

package/harness/bundles/general/cursor/harness-archive/SKILL.md

@@ -3,7 +3,7 @@ name: harness-archive
 description: 归档所有变更产出（计划/测试报告/审查/SQL/API文档）到 .harness/archive/，含归档元数据。仅当用户显式调用
   /harness-archive 时使用；不得被其他阶段 skill 自动接续触发。
 ---
-<!-- generated by harness_deploy.py; core=b246bb49cee55535; overlay=none; agent=cursor; do not edit -->
+<!-- generated by harness_deploy.py; core=041ded3368e8c2df; overlay=none; agent=cursor; do not edit -->
 # harness-archive — 变更归档
 
 ## Purpose

package/harness/bundles/general/cursor/harness-archive/reference.md

@@ -67,10 +67,39 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File "harness-skills/harness-
 - `changedFiles`：path/summary/insertions/deletions —— 来自 `git diff --numstat <base>..<head>`；
 - `reviewSummary`：red/yellow + redFixed/redConfirmed/yellowFixed/yellowDeferred 修复进度；
 - `maintenanceNotes`：给后续维护者看的结论；
-- `knownRisks`：剩余风险或人工确认项。
+- `knownRisks`：剩余风险或人工确认项；
+- `decisions`：已采纳的设计决策/需求/API 契约 —— 来自 `evidence/decisions.json`（见下节），生成器只做校验与透传，不从 markdown 提取。
 
 报告必须突出业务目标和维护者结论。所有统计数字只能来自 events、summary-data、ledger 或 manifest，不得手写另一套。历史 archive 没有 `events.ndjson` 时，允许从 ledger/log/manifest 回放，并在 `reportPipeline.sources` 中记录来源。
 
+## evidence/decisions.json（可选，知识沉淀入口）
+
+重要设计决策、长期约束、API 契约要进入平台知识库的唯一通道：在 plan/execute/review 阶段由人或 agent 把**已采纳**的结论写入 `.harness/changes/<change>/evidence/decisions.json`（schema_version 1）：
+
+```json
+{
+  "schema_version": 1,
+  "decisions": [
+    {
+      "id": "D-001",
+      "title": "一句话结论（必填，≤500 字）",
+      "rationale": "为什么（可选，≤4000 字）",
+      "entry_type": "decision | requirement | api-contract",
+      "status": "adopted | proposed | rejected | superseded",
+      "path": "docs/design/x.md（可选，相对路径，溯源用）",
+      "line": 42,
+      "keywords": ["可选，≤32 个"],
+      "source": "plan | review | manual | archive"
+    }
+  ]
+}
+```
+
+- 只有 `status: "adopted"` 的记录会成为知识候选（`entry_type` 原样落到知识条目上）；其余状态保留在 summary 里做记录。
+- 与 reviewFindings 的裁决门槛同源：**筛选必须在上游发生**——不要把讨论过程原文倒进来，归档时不做任何 LLM 提取。
+- 不合 schema 的记录会被丢弃并在 `maintenanceNotes` 留一条计数说明；丢弃不无声。
+- 未裁决（OPEN/UNKNOWN）的 RED/YELLOW findings 若导致候选为 0，finalize 会显式告警提示先裁决再 republish。
+
 ## 平台展示与数据校验
 
 平台监控直接读取 `reports/final/summary-data.json`，归档阶段不再生成本地 HTML 报告，也不得由模型临场维护第二份展示数据。

package/harness/bundles/general/cursor/harness-archive/templates/summary-data-template.json

@@ -213,5 +213,6 @@
   "uncommittedTestEvidence": [],
   "maintenanceNotes": [],
   "knownRisks": [],
+  "decisions": [],
   "manualActions": []
 }

package/harness/bundles/general/cursor/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=b246bb49cee55535; overlay=none; agent=cursor; do not edit -->
+<!-- generated by harness_deploy.py; core=041ded3368e8c2df; overlay=none; agent=cursor; do not edit -->
 # harness-codebase-map — 代码库地图
 
 ## Purpose

package/harness/bundles/general/cursor/harness-execute/SKILL.md

@@ -4,7 +4,7 @@ description: 执行阶段：按变更簇执行 TDD
   编码循环（RED→GREEN→REFACTOR→编译验证），随后完成单元/接口/数据兼容验证并输出测试报告。仅当用户显式调用
   /harness-execute 时使用；不得因用户提到编码/实现/测试就自动触发，也不得被其他阶段 skill 自动接续。
 ---
-<!-- generated by harness_deploy.py; core=b246bb49cee55535; overlay=none; agent=cursor; do not edit -->
+<!-- generated by harness_deploy.py; core=041ded3368e8c2df; overlay=none; agent=cursor; do not edit -->
 # harness-execute — 执行（编码 + 验证）
 
 > 2026-08 阶段合并：原 `run`（编码）与 `test`（验证）合并为单一 `execute` 阶段。

package/harness/bundles/general/cursor/harness-knowledge-ingest/SKILL.md

@@ -2,7 +2,7 @@
 name: harness-knowledge-ingest
 description: 确认归档 ZIP 已上传并由 Hunter Platform 在服务端解包、校验和入库。客户端不再构建或维护本地知识索引。
 ---
-<!-- generated by harness_deploy.py; core=b246bb49cee55535; overlay=none; agent=cursor; do not edit -->
+<!-- generated by harness_deploy.py; core=041ded3368e8c2df; overlay=none; agent=cursor; do not edit -->
 # harness-knowledge-ingest
 
 知识 ingest 完全由 Hunter Platform 负责。归档完成时，客户端生成一个确定性 ZIP；

package/harness/bundles/general/cursor/harness-knowledge-query/SKILL.md

@@ -2,7 +2,7 @@
 name: harness-knowledge-query
 description: 在规划、实现或排查前，通过 hunter-harness CLI 查询远端项目知识库。远端不可用时直接报告不可用，不建立本地索引或离线回退。
 ---
-<!-- generated by harness_deploy.py; core=b246bb49cee55535; overlay=none; agent=cursor; do not edit -->
+<!-- generated by harness_deploy.py; core=041ded3368e8c2df; overlay=none; agent=cursor; do not edit -->
 # harness-knowledge-query
 
 项目知识以 Hunter Platform 的服务端索引为唯一真源。客户端只提交查询并消费结果：