@hunter-harness/workflow-harness 0.2.54 → 0.2.56

package/harness/bundles/general/claude-code/scripts/harness_events_sync.py

@@ -51,6 +51,21 @@ WHITELIST = {
     "duration_ms",
     "schemaVersion",
     "summary",
+    "executor_tool",
+    "executor_agent",
+    "executor_model",
+    "execution_mode",
+    "decision_reason_code",
+    "fallback_reason_code",
+    "trigger",
+    "from_phase",
+    "result_status",
+    "planned_phases",
+    "skipped_phases",
+    "next_phase",
+    "phase_plan_source",
+    "closure_disposition",
+    "closure_reason",
 }
 
 MAX_BATCH_SIZE = 100
@@ -70,6 +85,14 @@ PHASE_LABELS = {
     "archive": "归档",
 }
 
+REVIEW_REASON_SUMMARIES = {
+    "REVIEW_DELEGATED": "已使用独立评审，主会话负责核验结果。",
+    "REVIEW_INLINE_UNAVAILABLE": "当前环境没有可用的隔离评审能力，已由主会话完成评审。",
+    "REVIEW_INLINE_SPAWN_FAILED": "独立评审启动失败，已由主会话完成评审。",
+    "REVIEW_INLINE_INVALID_RESULT": "独立评审未返回有效结果，已由主会话重新完成评审。",
+    "INLINE_BY_ADAPTER": "当前适配器未提供隔离评审，已由主会话完成评审。",
+}
+
 
 def _yaml_scalar(text: str, key: str) -> str | None:
     match = re.search(rf"(?m)^[ \t]*{re.escape(key)}:\s*['\"]?([^'\"\n#]+)", text)
@@ -110,20 +133,56 @@ def _summary_text(value: Any) -> str:
     return text[:EVENT_SUMMARY_MAX_LENGTH].rstrip()
 
 
+_MACHINE_DETAIL_RE = re.compile(
+    r"(?:\s*[；;,，]?\s*)"
+    r"(?:artifactsHash|artifactHash|receiptHash|content_sha256|contentSha256)"
+    r"\s*[:=]\s*(?:sha256:)?[0-9a-f]{32,64}",
+    re.IGNORECASE,
+)
+
+
+def _readable_summary_text(value: Any) -> str:
+    text = _summary_text(value)
+    if not text:
+        return ""
+    text = _MACHINE_DETAIL_RE.sub("", text)
+    text = re.sub(
+        r"\bfinalize\s+ok\b",
+        "规划产物已校验并发布",
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = re.sub(r"\s*([；;，,])\s*([；;，,])", r"\1", text)
+    return _summary_text(text.strip(" ；;，,"))
+
+
 def build_event_summary(event: dict[str, Any]) -> str:
-    explicit = _summary_text(event.get("summary"))
-    if explicit:
+    reason_code = _summary_text(
+        event.get("fallback_reason_code") or event.get("decision_reason_code")
+    )
+    reason_summary = REVIEW_REASON_SUMMARIES.get(reason_code)
+    explicit = _readable_summary_text(event.get("summary"))
+    if reason_summary and (
+        not explicit
+        or explicit == reason_code
+        or re.search(r"REVIEW_[A-Z0-9_]+|INLINE_BY_ADAPTER", explicit)
+    ):
+        return reason_summary
+    if explicit and not re.search(
+        r"\b[A-Z][A-Z0-9_]{3,}\b|\b[a-z][\w.-]+\s*=\s*(?:true|false)\b",
+        explicit,
+    ):
         return explicit
 
     event_type = _summary_text(event.get("type"))
     phase = _summary_text(event.get("phase"))
     phase_label = PHASE_LABELS.get(phase, phase or "当前")
-    note = _summary_text(event.get("note"))
-    message = _summary_text(event.get("message"))
-    decision = _summary_text(event.get("decision"))
-    reason = _summary_text(event.get("reason"))
-    name = _summary_text(event.get("name"))
-    code = _summary_text(event.get("code"))
+    note = _readable_summary_text(event.get("note"))
+    message = _readable_summary_text(event.get("message"))
+    decision = _readable_summary_text(event.get("decision"))
+    reason = _readable_summary_text(event.get("reason"))
+    name = _readable_summary_text(event.get("name"))
+    code = _readable_summary_text(event.get("code"))
     status = _summary_text(event.get("status"))
 
     if event_type == "decision" and decision:
@@ -145,6 +204,10 @@ def build_event_summary(event: dict[str, Any]) -> str:
         return _summary_text(
             f"{phase_label}阶段已结束：{detail}" if detail else f"{phase_label}阶段已结束。"
         )
+    if event_type == "gate.blocked":
+        return note or message or "阶段门禁暂未通过，现场已保留，可按提示恢复。"
+    if event_type == "gate.recovered":
+        return note or message or "阶段门禁已恢复，流程可以继续。"
     if event_type == "command":
         detail = name or note
         return _summary_text(f"执行步骤：{detail}" if detail else "执行了一项工作步骤。")
@@ -173,6 +236,48 @@ def sanitize(event: dict[str, Any]) -> dict[str, Any]:
     return payload
 
 
+def _workflow_plan(change_dir: Path) -> dict[str, Any] | None:
+    policy_path = change_dir / "meta" / "gate-policy.json"
+    if not policy_path.is_file():
+        return None
+    try:
+        policy = json.loads(policy_path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(policy, dict):
+        return None
+    raw = policy.get("plannedPhases")
+    source = "change"
+    if not isinstance(raw, list) or not raw:
+        raw = policy.get("defaultPhases")
+        source = "policy-default"
+    if not isinstance(raw, list):
+        return None
+    phases = [str(item).strip() for item in raw if str(item).strip()]
+    if not phases:
+        return None
+    skipped = policy.get("skippedPhases")
+    return {
+        "planned_phases": list(dict.fromkeys(phases)),
+        "skipped_phases": skipped if isinstance(skipped, list) else [],
+        "phase_plan_source": source,
+    }
+
+
+def _event_payload(event: dict[str, Any], phase_plan: dict[str, Any] | None) -> dict[str, Any]:
+    payload = sanitize(event)
+    if phase_plan is None:
+        return payload
+    payload.update(phase_plan)
+    if str(event.get("type") or "") in {"phase.end", "phase.auto_sealed"}:
+        phase = str(event.get("phase") or "").strip()
+        planned = phase_plan["planned_phases"]
+        if phase in planned:
+            index = planned.index(phase)
+            payload["next_phase"] = planned[index + 1] if index + 1 < len(planned) else None
+    return payload
+
+
 def _valid_display_title(value: Any) -> str | None:
     if not isinstance(value, str):
         return None
@@ -437,6 +542,7 @@ def sync_change(
         repair=True,
     )
     pending_raw = lines[acked:]
+    phase_plan = _workflow_plan(change_dir)
     uploaded = 0
     quarantined = 0
     last_result: dict[str, Any] | None = None
@@ -468,7 +574,7 @@ def sync_change(
                 "producer_seq": line_number,
                 "event_type": str(event.get("type") or "unknown"),
                 "occurred_at": str(event.get("timestamp") or event.get("ts") or client_time),
-                "payload": sanitize(event),
+                "payload": _event_payload(event, phase_plan),
             }
             if event.get("phase") is not None:
                 item["phase"] = event.get("phase")
@@ -695,6 +801,31 @@ class _CrossProcessLock:
             self._stream = None
 
 
+def _windowless_python_executable(
+    executable: str, base_executable: str | None
+) -> str:
+    """Return a Windows interpreter that cannot allocate a console window.
+
+    Virtual-environment ``python.exe`` files may be forwarding launchers.  Even
+    when the first process is created with ``CREATE_NO_WINDOW``, such a launcher
+    can start the real console interpreter and make Windows Terminal flash.  A
+    sibling ``pythonw.exe`` preserves the windowless subsystem across that hop.
+    """
+    executable_path = Path(executable)
+    candidates = [executable_path.with_name("pythonw.exe")]
+    if base_executable:
+        base_path = Path(base_executable)
+        base_windowless = base_path.with_name("pythonw.exe")
+        if base_windowless not in candidates:
+            candidates.append(base_windowless)
+    for candidate in candidates:
+        if candidate.is_file():
+            return str(candidate)
+    if base_executable and Path(base_executable).is_file():
+        return str(Path(base_executable))
+    return str(executable_path)
+
+
 def schedule_events_sync(project_root: Path, change_dir: Path) -> bool:
     """Wake a finite, project-local sync worker after an event is durable.
 
@@ -716,8 +847,14 @@ def schedule_events_sync(project_root: Path, change_dir: Path) -> bool:
     temporary = nudge.with_name(f".{nudge.name}.{uuid.uuid4().hex}.tmp")
     temporary.write_text(json.dumps(payload, separators=(",", ":")) + "\n", encoding="utf-8")
     os.replace(temporary, nudge)
+    interpreter = sys.executable
+    if os.name == "nt":
+        interpreter = _windowless_python_executable(
+            sys.executable,
+            getattr(sys, "_base_executable", None),
+        )
     command = [
-        sys.executable,
+        interpreter,
         str(Path(__file__).resolve()),
         "--project",
         str(project_root),
@@ -754,6 +891,39 @@ def _discover_changes(project_root: Path) -> list[Path]:
     return sorted(path for path in root.glob("*") if path.is_dir()) if root.is_dir() else []
 
 
+def _change_has_open_phase(change_dir: Path) -> bool:
+    """Project the append-only stream into open/closed phase state."""
+    try:
+        path = Path(harness_paths.resolve_state_dir_for_contract(change_dir)) / "events.ndjson"
+    except (OSError, ValueError):
+        return False
+    if not path.is_file():
+        return False
+    open_phases: dict[str, bool] = {}
+    try:
+        for line in path.read_text(encoding="utf-8-sig").splitlines():
+            if not line.strip():
+                continue
+            event = json.loads(line)
+            if not isinstance(event, dict):
+                continue
+            phase = event.get("phase")
+            event_type = event.get("type")
+            if not isinstance(phase, str) or not phase:
+                continue
+            if event_type == "phase.start":
+                open_phases[phase] = True
+            elif event_type in {"phase.end", "phase.auto_sealed", "workflow.end", "run.end"}:
+                open_phases[phase] = False
+    except (OSError, json.JSONDecodeError):
+        return False
+    return any(open_phases.values())
+
+
+def _project_has_open_phase(project_root: Path) -> bool:
+    return any(_change_has_open_phase(path) for path in _discover_changes(project_root))
+
+
 def _run_agent_session(project_root: Path) -> dict[str, Any]:
     attempts = 0
     uploaded = 0
@@ -766,14 +936,28 @@ def _run_agent_session(project_root: Path) -> dict[str, Any]:
         if all(item.get("ok") for item in results):
             time.sleep(0.6)
             if generation == _read_nudge_generation(project_root):
-                return {
-                    "ok": True,
-                    "uploaded": uploaded,
-                    "quarantined": quarantined,
-                    "attempts": attempts + 1,
-                }
+                if not _project_has_open_phase(project_root):
+                    return {
+                        "ok": True,
+                        "uploaded": uploaded,
+                        "quarantined": quarantined,
+                        "attempts": attempts + 1,
+                    }
+                # Keep a finite workflow lease alive while a phase is open.
+                # A phase.end nudge is observed on the next pass and releases
+                # the worker naturally; no terminal window is created.
+                time.sleep(10.0)
+                heartbeat_results = [
+                    sync_change(project_root, path, heartbeat_only=True)
+                    for path in _discover_changes(project_root)
+                ]
+                if all(item.get("ok") for item in heartbeat_results):
+                    attempts = 0
+                    continue
+                results = heartbeat_results
             attempts = 0
-            continue
+            if generation != _read_nudge_generation(project_root):
+                continue
         time.sleep(min(16.0, float(2 ** attempts)))
         attempts += 1
     return {

package/harness/bundles/general/claude-code/scripts/harness_fixback.py

@@ -11,6 +11,7 @@ import os
 import re
 import tempfile
 import sys
+import uuid
 from pathlib import Path
 from typing import Any
 
@@ -19,6 +20,7 @@ if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
 from harness_paths import resolve_state_dir_for_contract
+import harness_events as he
 
 
 SCHEMA_VERSION = 1
@@ -96,6 +98,171 @@ def _all_batches(change_dir: Path) -> list[dict[str, Any]]:
     return batches
 
 
+def _session_path(change_dir: Path) -> Path:
+    return _state_root(change_dir) / "runtime" / "fixback-session.json"
+
+
+def _next_step(batch: dict[str, Any]) -> str:
+    issues = [item for item in batch.get("issues", []) if isinstance(item, dict)]
+    if not issues:
+        return "add-issues"
+    if any(item.get("status") != "RESOLVED" for item in issues):
+        return "resolve-issues"
+    receipts = batch.get("receipts") if isinstance(batch.get("receipts"), dict) else {}
+    if not receipts.get("affected"):
+        return "verify-affected"
+    if not receipts.get("review"):
+        return "review"
+    return "close"
+
+
+def resume_batch(
+    change_dir: Path,
+    *,
+    batch_id: str | None,
+    product_identity: str | None,
+    root_cause: str | None,
+    run_id: str | None,
+    attempt: int | None,
+) -> dict[str, Any]:
+    """Open once or resume the active Fixback session with a stable run identity."""
+    opened = [item for item in _all_batches(change_dir) if item.get("status") == "OPEN"]
+    resumed = bool(opened)
+    if opened:
+        batch = sorted(opened, key=lambda item: str(item.get("openedAt") or ""))[0]
+    else:
+        if not batch_id or not product_identity or not root_cause:
+            raise ValueError(
+                "FIXBACK_RESUME_INPUT_REQUIRED: new sessions require batch-id, "
+                "product-identity and root-cause"
+            )
+        batch = open_batch(
+            change_dir,
+            batch_id=batch_id,
+            product_identity=product_identity,
+            root_cause=root_cause,
+        )
+    session_path = _session_path(change_dir)
+    existing: dict[str, Any] = {}
+    if session_path.is_file():
+        try:
+            loaded = json.loads(session_path.read_text(encoding="utf-8-sig"))
+            existing = loaded if isinstance(loaded, dict) else {}
+        except (OSError, json.JSONDecodeError):
+            existing = {}
+    same_open_session = (
+        existing.get("status") == "ACTIVE"
+        and existing.get("batchId") == batch.get("batchId")
+    )
+    effective_run_id = (
+        str(existing.get("runId"))
+        if same_open_session and existing.get("runId")
+        else str(run_id or "fixback-" + uuid.uuid4().hex)
+    )
+    effective_attempt = (
+        int(existing.get("attempt"))
+        if same_open_session and isinstance(existing.get("attempt"), int)
+        else max(1, int(attempt or 1))
+    )
+    next_step = _next_step(batch)
+    session = {
+        "schemaVersion": 1,
+        "status": "ACTIVE",
+        "batchId": batch.get("batchId"),
+        "runId": effective_run_id,
+        "attempt": effective_attempt,
+        "nextStep": next_step,
+        "updatedAt": now_iso(),
+    }
+    _write_json(session_path, session)
+    he.append_event(
+        change_dir,
+        phase="run",
+        type_="decision",
+        note=(
+            "已恢复现有修复批次，将从未完成步骤继续。"
+            if resumed
+            else "已创建修复批次，将按问题逐项执行 RED/GREEN。"
+        ),
+        run_id=effective_run_id,
+    )
+    return {
+        "ok": True,
+        "code": "FIXBACK_RESUMED" if resumed else "FIXBACK_OPENED",
+        "resumed": resumed,
+        "batchId": batch.get("batchId"),
+        "runId": effective_run_id,
+        "attempt": effective_attempt,
+        "nextStep": next_step,
+        "requiredVerifications": batch.get("requiredVerifications", []),
+        "changedFiles": batch.get("changedFiles", []),
+        "sessionPath": str(session_path),
+    }
+
+
+def invalidate_affected_evidence(
+    change_dir: Path,
+    *,
+    changed_files: list[str],
+    batch_id: str,
+) -> dict[str, Any]:
+    """Invalidate only verification targets whose declared inputs were changed."""
+    normalized = {
+        str(path).replace("\\", "/").lstrip("./")
+        for path in changed_files
+        if str(path).strip()
+    }
+    ledger_path = _state_root(change_dir) / "evidence" / "verification-ledger.json"
+    if not normalized or not ledger_path.is_file():
+        return {"ok": True, "targetIds": [], "validations": []}
+    try:
+        ledger = json.loads(ledger_path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError):
+        return {"ok": False, "code": "FIXBACK_LEDGER_INVALID"}
+    if not isinstance(ledger, dict):
+        return {"ok": False, "code": "FIXBACK_LEDGER_INVALID"}
+
+    def affected(entry: dict[str, Any]) -> bool:
+        inputs = entry.get("inputsFiles")
+        if not isinstance(inputs, list):
+            return False
+        input_set = {
+            str(path).replace("\\", "/").lstrip("./")
+            for path in inputs
+            if str(path).strip()
+        }
+        return bool(normalized & input_set)
+
+    invalidation = {
+        "code": "FIXBACK_AFFECTED_INPUT_CHANGED",
+        "batchId": batch_id,
+        "changedFiles": sorted(normalized),
+        "invalidatedAt": now_iso(),
+    }
+    target_ids: list[str] = []
+    targets = ledger.get("verificationTargets")
+    if isinstance(targets, dict):
+        for target_id, target in targets.items():
+            if isinstance(target, dict) and affected(target):
+                target["reusable"] = False
+                target["invalidation"] = dict(invalidation)
+                target_ids.append(str(target_id))
+    validation_names: list[str] = []
+    validations = ledger.get("validations")
+    if isinstance(validations, dict):
+        for name, entry in validations.items():
+            if isinstance(entry, dict) and affected(entry):
+                entry["reusable"] = False
+                entry["invalidation"] = dict(invalidation)
+                validation_names.append(str(name))
+    _write_json(ledger_path, ledger)
+    return {
+        "ok": True,
+        "targetIds": sorted(target_ids),
+        "validations": sorted(validation_names),
+    }
+
+
 def _required_verifications(issues: list[dict[str, Any]]) -> list[str]:
     required = {"affected", "review"}
     for issue in issues:
@@ -506,6 +673,11 @@ def resolve_issue(
         }
     )
     batch["updatedAt"] = resolved_at
+    batch["invalidation"] = invalidate_affected_evidence(
+        change_dir,
+        changed_files=[record["path"] for record in changed_records],
+        batch_id=batch_id,
+    )
     _write_json(_batch_path(change_dir, batch_id), batch)
     return issue
 
@@ -652,6 +824,13 @@ def _emit(value: dict[str, Any]) -> int:
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="harness_fixback.py")
     sub = parser.add_subparsers(dest="command", required=True)
+    resume = sub.add_parser("resume")
+    resume.add_argument("--change-dir", required=True)
+    resume.add_argument("--batch-id")
+    resume.add_argument("--product-identity")
+    resume.add_argument("--root-cause")
+    resume.add_argument("--run-id")
+    resume.add_argument("--attempt", type=int)
     opened = sub.add_parser("open")
     opened.add_argument("--change-dir", required=True)
     opened.add_argument("--batch-id", required=True)
@@ -692,7 +871,16 @@ def main(argv: list[str] | None = None) -> int:
     args = build_parser().parse_args(argv)
     change_dir = Path(args.change_dir)
     try:
-        if args.command == "open":
+        if args.command == "resume":
+            value = resume_batch(
+                change_dir,
+                batch_id=args.batch_id,
+                product_identity=args.product_identity,
+                root_cause=args.root_cause,
+                run_id=args.run_id,
+                attempt=args.attempt,
+            )
+        elif args.command == "open":
             value = open_batch(
                 change_dir,
                 batch_id=args.batch_id,