@hunter-harness/workflow-harness 0.2.46 → 0.2.48

package/harness/bundles/general/codebuddy/scripts/harness_archive.py

@@ -5024,6 +5024,14 @@ def render_fallback_html(summary: dict[str, Any]) -> str:
 """
 
 
+
+# P1 slim-files: final-summary.html is a regenerable presentation layer over
+# summary-data.json. `finalize --no-html` skips local HTML rendering entirely
+# (a remote platform can render from summary-data.json); render failures are
+# downgraded to warnings instead of rolling back the archive.
+RENDER_HTML_ENABLED = True
+
+
 def render_final_summary(
     change_dir: Path,
     summary_path: Path,
@@ -5034,9 +5042,18 @@ def render_final_summary(
     - Node success -> renderer="node".
     - Node unavailable/timeout/non-zero/no-file -> Python fallback; success ->
       renderer="python-fallback" (fallbackReason carries the node failure cause).
-    - Both fail or produce no file -> ok=False (caller must restore + exit non-0).
+    - Both fail or produce no file -> ok=False (caller downgrades to warning).
+    - Rendering disabled (--no-html) -> ok=True with renderer="skipped".
     """
     out_path = change_dir / "reports" / "final" / "final-summary.html"
+    if not RENDER_HTML_ENABLED:
+        return {
+            "ok": True,
+            "renderer": "skipped",
+            "fallbackReason": "",
+            "out_path": str(out_path),
+            "skipped": True,
+        }
     project = find_project_root(change_dir)
     node = resolve_node_path(project)
     fallback_reason = ""
@@ -5418,12 +5435,14 @@ def validate_summary(
                 }
             )
     else:
-        # Task 2 (§4.1 rule 5): 不再存在"没有 HTML 但只 warning"的分支。
-        # 缺 final-summary 恒为 error；finalize 会 restore + exit 非 0。
+        # P1 slim-files: final-summary.html 是 summary-data.json 的可再生展示
+        # 投影，不再是硬产物（summary-data + manifest + adequacy 仍 fail-closed）。
+        # 缺 HTML 恒为 warning，不阻断归档收尾；平台端可按 summary-data 渲染。
+        _ = render_skipped  # kept for call-site compatibility
         issues.append(
             {
                 "code": "missing-final-report",
-                "severity": "error",
+                "severity": "warning",
                 "message": "reports/final/final-summary.html not found",
             }
         )
@@ -7996,13 +8015,10 @@ def cmd_finalize(
     render_result = render_final_summary(work_dir, summary_path)
     payload["steps"]["render"] = render_result
     if not render_result.get("ok"):
-        # 永不关闭一个没有 final-summary 的归档。
+        # final-summary.html 是 summary-data.json 的可再生展示层：渲染失败
+        # 降级为 warning，归档继续（平台端可按 summary-data 重新渲染）。
         msg = str(render_result.get("fallbackReason") or "render failed")
-        payload["error"] = f"final-summary render failed: {msg}"
-        _restore_finalize_failure()
-        payload["warnings"] = warnings
-        payload["ok"] = False
-        return 1, payload
+        warnings.append(f"final-summary render failed (archive continues): {msg}")
     renderer = render_result.get("renderer")
     if renderer == "python-fallback" and render_result.get("fallbackReason"):
         warnings.append(
@@ -8053,9 +8069,10 @@ def cmd_finalize(
     write_json(summary_path, summary)
     render_result = render_final_summary(work_dir, summary_path)
     if not render_result.get("ok"):
-        payload["error"] = f"final summary re-render failed: {render_result.get('error')}"
-        _restore_finalize_failure()
-        return 1, payload
+        warnings.append(
+            "final summary re-render failed (archive continues): "
+            f"{render_result.get('fallbackReason') or render_result.get('error')}"
+        )
     summary = read_json(summary_path)
     validate_result = validate_summary(summary, html_path if html_path.is_file() else None)
     payload["steps"]["validate"] = validate_result
@@ -8092,11 +8109,10 @@ def cmd_finalize(
         write_json(summary_path, summary)
         render_result = render_final_summary(work_dir, summary_path)
         if not render_result.get("ok"):
-            payload["error"] = (
-                f"post-manifest summary render failed: {render_result.get('error')}"
+            warnings.append(
+                "post-manifest summary render failed (archive continues): "
+                f"{render_result.get('fallbackReason') or render_result.get('error')}"
             )
-            _restore_finalize_failure()
-            return 1, payload
         coverage = verify_manifest_byte_coverage(
             work_dir,
             after_manifest,
@@ -8345,6 +8361,13 @@ def cmd_finalize(
     except OSError as exc:
         warnings.append(f"could not persist completed archive operation: {exc}")
 
+    # P4: when remote credentials exist, auto-push the core four
+    # (design/plan/summary-data/knowledge) via the existing push channel.
+    push_result = auto_push_archive_core(project_root, archive_dir)
+    payload["steps"]["archive_push"] = push_result
+    if push_result.get("warning"):
+        warnings.append(str(push_result["warning"]))
+
     payload["ok"] = True
     payload["finalStatus"] = "OK"
     payload["warnings"] = warnings
@@ -8353,6 +8376,122 @@ def cmd_finalize(
     return 0, payload
 
 
+def _remote_credentials_configured(project_root: Path) -> bool:
+    creds = project_root / ".harness" / "credentials.local.yaml"
+    if not creds.is_file():
+        return False
+    text = creds.read_text(encoding="utf-8", errors="ignore")
+    has_url = bool(re.search(r"(?m)^[ \t]*server_url:\s*\S+", text))
+    has_token = bool(re.search(r"(?m)^[ \t]*token:\s*\S+", text))
+    return has_url and has_token
+
+
+def collect_archive_core_paths(project_root: Path, archive_dir: Path) -> list[str]:
+    """Relative paths for the P4 core four push set."""
+    root = project_root.resolve()
+    archive = archive_dir.resolve()
+    paths: list[str] = []
+
+    def add_if_exists(absolute: Path) -> None:
+        if absolute.is_file():
+            paths.append(absolute.relative_to(root).as_posix())
+
+    add_if_exists(archive / "reports" / "final" / "summary-data.json")
+    for folder in ("spec", "plans"):
+        base = archive / folder
+        if base.is_dir():
+            for path in sorted(base.rglob("*")):
+                if path.is_file():
+                    paths.append(path.relative_to(root).as_posix())
+    knowledge = root / ".harness" / "knowledge" / "entries"
+    for status in ("active", "candidate"):
+        folder = knowledge / status
+        if folder.is_dir():
+            for path in sorted(folder.glob("*.json")):
+                paths.append(path.relative_to(root).as_posix())
+    return paths
+
+
+def auto_push_archive_core(project_root: Path, archive_dir: Path) -> dict[str, Any]:
+    """Best-effort remote push of archive core artifacts after finalize.
+
+    Skips silently when credentials are absent. Failures become warnings so
+    archive success is never rolled back by a push outage.
+    """
+    project_root = project_root.resolve()
+    if not _remote_credentials_configured(project_root):
+        return {"skipped": True, "reason": "no remote credentials"}
+    core_paths = collect_archive_core_paths(project_root, archive_dir)
+    pending = {
+        "schemaVersion": 1,
+        "generatedAt": now_iso(),
+        "archiveDir": str(archive_dir),
+        "paths": core_paths,
+    }
+    pending_path = project_root / ".harness" / "state" / "archive-push-pending.json"
+    try:
+        pending_path.parent.mkdir(parents=True, exist_ok=True)
+        write_json(pending_path, pending)
+    except OSError as exc:
+        return {
+            "skipped": False,
+            "ok": False,
+            "paths": core_paths,
+            "warning": f"could not write archive-push-pending.json: {exc}",
+        }
+
+    # Prefer the published CLI; fall back to recording the pending receipt only.
+    command = [
+        "npx",
+        "--yes",
+        "hunter-harness",
+        "push",
+        "--yes",
+        "--non-interactive",
+        "--json",
+    ]
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=str(project_root),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=180,
+            shell=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return {
+            "skipped": False,
+            "ok": False,
+            "paths": core_paths,
+            "pending": str(pending_path),
+            "warning": f"archive auto-push deferred: {exc}",
+        }
+    ok = completed.returncode == 0
+    result: dict[str, Any] = {
+        "skipped": False,
+        "ok": ok,
+        "paths": core_paths,
+        "pending": str(pending_path),
+        "exitCode": completed.returncode,
+    }
+    if not ok:
+        result["warning"] = (
+            "archive auto-push failed (exit "
+            + str(completed.returncode)
+            + "); pending receipt kept for retry via `hunter-harness push`"
+        )
+        if completed.stderr.strip():
+            result["stderr"] = completed.stderr.strip()[:500]
+    else:
+        try:
+            pending_path.unlink(missing_ok=True)
+        except OSError:
+            pass
+    return result
+
+
 def _merge_runtime_state(state_dir: Path, contract_dir: Path) -> None:
     """Materialize split-v1 dynamic state into the archive contract tree."""
     for source in sorted(state_dir.iterdir()):
@@ -8513,6 +8652,9 @@ def cmd_certify_local_cli(args: argparse.Namespace) -> int:
 
 
 def cmd_finalize_cli(args: argparse.Namespace) -> int:
+    global RENDER_HTML_ENABLED
+    if getattr(args, "no_html", False):
+        RENDER_HTML_ENABLED = False
     change_dir = resolve_path(args.change_dir)
     archive_root = resolve_path(args.archive_root)
     durable_root = (
@@ -8801,6 +8943,11 @@ def build_parser() -> argparse.ArgumentParser:
         default="release-candidate",
         help="release-candidate enforces candidate evidence; record-only archives facts without release eligibility",
     )
+    p_fin.add_argument(
+        "--no-html",
+        action="store_true",
+        help="skip local final-summary.html rendering (summary-data.json stays canonical)",
+    )
     p_fin.add_argument("--json", action="store_true", default=True)
     p_fin.set_defaults(func=cmd_finalize_cli)
 

package/harness/bundles/general/codebuddy/scripts/harness_events.py

@@ -1424,6 +1424,34 @@ def write_execution_log(change_dir: Path, content: str) -> Path:
     return path
 
 
+def execution_log_render_enabled(change_dir: Path) -> bool:
+    """P1 slim-files: execution-log.md auto-render policy.
+
+    `.harness/config/render-policy.json` with ``{"executionLog": "on-demand"}``
+    disables the automatic render on ``phase.end``/auto-seal; the explicit
+    ``harness_events.py render`` subcommand rebuilds the projection at any
+    time. Default stays "auto" (render on phase.end).
+    """
+    current = change_dir.resolve()
+    for candidate in [current, *current.parents]:
+        if candidate.name == ".harness":
+            config = candidate / "config" / "render-policy.json"
+        else:
+            config = candidate / ".harness" / "config" / "render-policy.json"
+        if not config.is_file():
+            continue
+        try:
+            document = json.loads(config.read_text(encoding="utf-8-sig"))
+        except (OSError, json.JSONDecodeError):
+            return True
+        if isinstance(document, dict):
+            mode = str(document.get("executionLog") or "").strip().lower()
+            if mode == "on-demand":
+                return False
+        return True
+    return True
+
+
 def build_summary(change_dir: Path, events: list[dict[str, Any]]) -> dict[str, Any]:
     phases: dict[str, Any] = {}
     issues: list[dict[str, Any]] = []
@@ -1774,7 +1802,8 @@ def cmd_append(args: argparse.Namespace) -> int:
     rendered = False
     log_path = None
     log_lines = None
-    if args.type == "phase.end" or auto_sealed_events:
+    if (args.type == "phase.end" or auto_sealed_events) and \
+            execution_log_render_enabled(change_dir):
         try:
             events = load_events(path)
             content = render_execution_log(events)

package/harness/bundles/general/codebuddy/scripts/harness_events_sync.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""P4: sync local events.ndjson to the platform Run monitoring API.
+
+Reads `.harness/credentials.local.yaml` + project_id, whitelists event fields,
+POSTs batches with ACK cursor, and sends heartbeats. Offline-safe: cursor only
+advances on accepted/duplicate_accepted responses.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+WHITELIST = {
+    "id",
+    "ts",
+    "type",
+    "phase",
+    "status",
+    "note",
+    "attempt",
+    "name",
+    "code",
+    "severity",
+    "decision",
+    "reason",
+    "exit_code",
+    "duration_ms",
+    "schemaVersion",
+}
+
+
+def _yaml_scalar(text: str, key: str) -> str | None:
+    match = re.search(rf"(?m)^[ \t]*{re.escape(key)}:\s*['\"]?([^'\"\n#]+)", text)
+    if match is None:
+        return None
+    value = match.group(1).strip()
+    return value or None
+
+
+def load_endpoint(project: Path) -> dict[str, str] | None:
+    creds = project / ".harness" / "credentials.local.yaml"
+    if not creds.is_file():
+        return None
+    text = creds.read_text(encoding="utf-8", errors="ignore")
+    server_url = _yaml_scalar(text, "server_url")
+    token = _yaml_scalar(text, "token")
+    project_id = _yaml_scalar(text, "project_id")
+    if not project_id:
+        py = project / ".harness" / "project.yaml"
+        if py.is_file():
+            project_id = _yaml_scalar(py.read_text(encoding="utf-8", errors="ignore"), "project_id")
+    if not server_url or not token or not project_id:
+        return None
+    if project_id.lower() in {"null", "~", "none"}:
+        return None
+    return {
+        "server_url": server_url.rstrip("/"),
+        "token": token,
+        "project_id": project_id,
+    }
+
+
+def sanitize(event: dict[str, Any]) -> dict[str, Any]:
+    return {key: event[key] for key in WHITELIST if key in event}
+
+
+def cursor_path(change_dir: Path) -> Path:
+    return change_dir / "meta" / "events-sync-cursor.json"
+
+
+def load_cursor(change_dir: Path) -> int:
+    path = cursor_path(change_dir)
+    if not path.is_file():
+        return 0
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return 0
+    return int(data.get("acked_lines") or 0)
+
+
+def save_cursor(change_dir: Path, acked_lines: int) -> None:
+    path = cursor_path(change_dir)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps({"schemaVersion": 1, "acked_lines": acked_lines}, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def run_id_for(change_dir: Path) -> str:
+    # Stable opaque id from absolute path — no hostname/username leakage.
+    digest = hashlib.sha256(str(change_dir.resolve()).encode("utf-8")).hexdigest()[:24]
+    return "run_" + digest
+
+
+def post_json(endpoint: dict[str, str], path: str, body: dict[str, Any]) -> dict[str, Any]:
+    url = endpoint["server_url"] + path
+    data = json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+    request = urllib.request.Request(
+        url,
+        data=data,
+        method="POST",
+        headers={
+            "Accept": "application/json",
+            "Authorization": f"Bearer {endpoint['token']}",
+            "Content-Type": "application/json",
+        },
+    )
+    with urllib.request.urlopen(request, timeout=30) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def sync_change(project: Path, change_dir: Path, *, heartbeat_only: bool = False) -> dict[str, Any]:
+    endpoint = load_endpoint(project)
+    if endpoint is None:
+        return {"ok": True, "skipped": True, "reason": "remote credentials not configured"}
+    change_key = change_dir.name
+    rid = run_id_for(change_dir)
+    project_id = endpoint["project_id"]
+
+    # Always heartbeat so the console can separate connection vs run status.
+    try:
+        from datetime import datetime, timezone
+
+        client_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        post_json(
+            endpoint,
+            f"/api/v1/projects/{project_id}/runs/heartbeats",
+            {
+                "protocol_version": "hunter-progress-sync/v1",
+                "run_id": rid,
+                "change_key": change_key,
+                "client_time": client_time,
+                "title": change_key,
+            },
+        )
+    except (urllib.error.URLError, TimeoutError, OSError, json.JSONDecodeError) as exc:
+        return {"ok": False, "error": f"heartbeat failed: {exc}", "run_id": rid}
+
+    if heartbeat_only:
+        return {"ok": True, "heartbeat": True, "run_id": rid}
+
+    events_file = change_dir / "events.ndjson"
+    if not events_file.is_file():
+        return {"ok": True, "run_id": rid, "uploaded": 0, "reason": "no events.ndjson"}
+
+    lines = events_file.read_text(encoding="utf-8").splitlines()
+    acked = load_cursor(change_dir)
+    pending_raw = lines[acked:]
+    batch: list[dict[str, Any]] = []
+    for offset, line in enumerate(pending_raw, start=1):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+        event_id = str(event.get("id") or f"{change_key}:{acked + offset}")
+        payload = sanitize(event)
+        batch.append(
+            {
+                "event_id": event_id,
+                "producer_seq": acked + offset,
+                "event_type": str(event.get("type") or "unknown"),
+                "phase": event.get("phase"),
+                "occurred_at": str(event.get("ts") or client_time),
+                "payload": payload,
+            }
+        )
+    if not batch:
+        save_cursor(change_dir, len(lines))
+        return {"ok": True, "run_id": rid, "uploaded": 0, "acked_lines": len(lines)}
+
+    # Drop None phase keys for strict schema.
+    for item in batch:
+        if item.get("phase") is None:
+            item.pop("phase", None)
+
+    try:
+        result = post_json(
+            endpoint,
+            f"/api/v1/projects/{project_id}/runs/events:batch",
+            {
+                "protocol_version": "hunter-progress-sync/v1",
+                "run_id": rid,
+                "change_key": change_key,
+                "title": change_key,
+                "events": batch,
+            },
+        )
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")
+        return {"ok": False, "error": f"batch HTTP {exc.code}: {detail}", "run_id": rid}
+    except (urllib.error.URLError, TimeoutError, OSError, json.JSONDecodeError) as exc:
+        return {"ok": False, "error": f"batch failed: {exc}", "run_id": rid}
+
+    items = result.get("items") if isinstance(result, dict) else None
+    accepted = 0
+    if isinstance(items, list):
+        for item in items:
+            status = str((item or {}).get("status") or "")
+            if status in {"accepted", "duplicate_accepted"}:
+                accepted += 1
+    # Advance cursor only when the whole batch was accepted/duplicated.
+    if accepted == len(batch):
+        save_cursor(change_dir, acked + len(pending_raw))
+        acked_lines = acked + len(pending_raw)
+    else:
+        acked_lines = acked
+    return {
+        "ok": accepted == len(batch),
+        "run_id": rid,
+        "uploaded": accepted,
+        "batch_size": len(batch),
+        "acked_lines": acked_lines,
+        "server": result,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Sync events.ndjson to platform Run monitoring")
+    parser.add_argument("--project", default=".", help="Project root")
+    parser.add_argument("--change-dir", help="Specific change directory")
+    parser.add_argument("--heartbeat-only", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    project = Path(args.project).resolve()
+    if args.change_dir:
+        changes = [Path(args.change_dir).resolve()]
+    else:
+        root = project / ".harness" / "changes"
+        changes = sorted(path for path in root.glob("*") if path.is_dir()) if root.is_dir() else []
+    results = [
+        sync_change(project, change_dir, heartbeat_only=args.heartbeat_only)
+        for change_dir in changes
+    ]
+    ok = all(item.get("ok") for item in results) if results else True
+    # P5 headless envelope — stable for orchestrators.
+    payload = {
+        "schema_version": 1,
+        "ok": ok,
+        "command": "events.sync",
+        "change": None,
+        "phase": None,
+        "exit_code": 0 if ok else 1,
+        "warnings": [],
+        "errors": [] if ok else [{"message": "one or more change syncs failed"}],
+        "result": {"results": results},
+        # Backward-compatible aliases used by early callers / tests.
+        "results": results,
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())