@hunter-harness/workflow-harness 0.2.8 → 0.2.10

package/harness/bundles/java/claude-code/scripts/harness_change.py

@@ -31,6 +31,8 @@ SCRIPTS_DIR = Path(__file__).resolve().parent
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
+import harness_paths  # noqa: E402
+
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
 if hasattr(sys.stderr, "reconfigure"):
@@ -208,6 +210,20 @@ def change_dir_for_id(project_root: Path, change_id: str) -> Path | None:
     return None
 
 
+def _layout_fields(project_root: Path, change_id: str) -> dict[str, Any]:
+    """Layout enrichment for resolve payloads; empty on any resolution issue."""
+    try:
+        layout = harness_paths.resolve_change_layout(project_root, change_id)
+    except (FileNotFoundError, ValueError, OSError):
+        return {}
+    return {
+        "contractRoot": layout["contractRoot"],
+        "stateRoot": layout["stateRoot"],
+        "layout": layout["layout"],
+        "repositoryId": layout["repositoryId"],
+    }
+
+
 def resolve_change(
     project_root: Path,
     change_id: str | None,
@@ -229,6 +245,7 @@ def resolve_change(
             "changeDir": str(resolved),
             "projectRoot": str(project_root.resolve()),
             "activeCount": len(active),
+            **_layout_fields(project_root, change_id),
         }
     if not active:
         return {
@@ -247,6 +264,7 @@ def resolve_change(
             "projectRoot": str(project_root.resolve()),
             "activeCount": 1,
             "autoSelected": True,
+            **_layout_fields(project_root, only["changeId"]),
         }
     return {
         "ok": False,

package/harness/bundles/java/claude-code/scripts/harness_deploy.py

@@ -719,40 +719,6 @@ def cmd_install(build_out: Path, project: Path, target: Path | None) -> dict[str
     }
 
 
-def cmd_diff(build_out: Path, project: Path, target: Path | None) -> dict[str, Any]:
-    build_out = build_out.resolve()
-    project = project.resolve()
-    installed = (target or project / ".claude" / "skills").resolve()
-    if not installed.is_dir():
-        return {
-            "ok": True,
-            "action": "diff",
-            "stale": True,
-            "missingInstall": True,
-            "outdated": [],
-            "missing": [],
-            "extra": [],
-        }
-
-    built = collect_files(build_out)
-    current = collect_files(installed)
-    outdated = [p for p, h in built.items() if p in current and current[p] != h]
-    missing = [p for p in built if p not in current]
-    # extra includes install-side managed manifests only as metadata, so they
-    # are excluded from the extra set; every other untracked file is a real
-    # extra and must mark the install stale (design §3.8 要点3).
-    extra = [p for p in current if p not in built and p not in INSTALL_METADATA]
-    return {
-        "ok": True,
-        "action": "diff",
-        "stale": bool(outdated or missing or extra),
-        "outdated": sorted(outdated),
-        "missing": sorted(missing),
-        "extra": sorted(extra),
-        "comparedAt": now_iso(),
-    }
-
-
 def cmd_validate_manifest(
     bundle_dir: Path, manifest_entries: list[dict[str, Any]]
 ) -> dict[str, Any]:
@@ -783,7 +749,7 @@ def cmd_validate_manifest(
 
 
 def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(description="Harness skills deploy (build/install/diff)")
+    p = argparse.ArgumentParser(description="Harness skills deploy (build/install)")
     sub = p.add_subparsers(dest="command", required=True)
 
     b = sub.add_parser("build", help="Synthesize core + overlay into output dir")
@@ -799,12 +765,6 @@ def build_parser() -> argparse.ArgumentParser:
     i.add_argument("--target", type=Path)
     i.add_argument("--json", action="store_true")
 
-    d = sub.add_parser("diff", help="Compare installed skills vs build output")
-    d.add_argument("--from", dest="from_dir", type=Path, required=True)
-    d.add_argument("--project", type=Path, required=True)
-    d.add_argument("--target", type=Path)
-    d.add_argument("--json", action="store_true")
-
     v = sub.add_parser(
         "validate-manifest", help="Validate bundle dir vs manifest (missing/extra/hash)"
     )
@@ -823,9 +783,6 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "install":
             result = cmd_install(args.from_dir, args.project, args.target)
             return emit_json(result) if args.json else 0
-        if args.command == "diff":
-            result = cmd_diff(args.from_dir, args.project, args.target)
-            return emit_json(result) if args.json else 0
         if args.command == "validate-manifest":
             manifest_data = json.loads(args.manifest.read_text(encoding="utf-8"))
             entries = (

package/harness/bundles/java/claude-code/scripts/harness_events.py

@@ -23,6 +23,12 @@ import uuid
 from pathlib import Path
 from typing import Any
 
+SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+import harness_paths  # noqa: E402
+
 
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
@@ -43,6 +49,7 @@ EVENT_TYPES = frozenset(
 )
 
 SCHEMA_VERSION = 3
+_NOTE_FALLBACK_MAXLEN = 60
 HEADER_LINE = (
     "本文件由 harness_events.py 自动渲染，请勿手工编辑；事实源为 events.ndjson"
 )
@@ -98,12 +105,16 @@ def resolve_change_dir(raw: str) -> Path:
     return Path(raw).expanduser().resolve()
 
 
+def _state_dir(change_dir: Path) -> Path:
+    return Path(harness_paths.resolve_state_dir_for_contract(change_dir))
+
+
 def events_path(change_dir: Path) -> Path:
-    return change_dir / "events.ndjson"
+    return _state_dir(change_dir) / "events.ndjson"
 
 
 def execution_log_path(change_dir: Path) -> Path:
-    return change_dir / "logs" / "execution-log.md"
+    return _state_dir(change_dir) / "logs" / "execution-log.md"
 
 
 def archived_change_dir(change_dir: Path) -> Path | None:
@@ -178,6 +189,26 @@ def load_events(path: Path) -> list[dict[str, Any]]:
     return events
 
 
+def merge_event_files(paths: list[Path]) -> list[dict[str, Any]]:
+    """Union events from multiple NDJSON files by event ID (UT-001/RET-05).
+
+    Each event ID appears exactly once; first-seen copy wins. Missing IDs are
+    kept keyed by (file index, line number) so unidentified events are never
+    silently dropped.
+    """
+    merged: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for path in paths:
+        for event in load_events(Path(path)):
+            event_id = str(event.get("id") or "").strip()
+            if event_id:
+                if event_id in seen:
+                    continue
+                seen.add(event_id)
+            merged.append(event)
+    return merged
+
+
 def atomic_append_line(path: Path, line: str) -> None:
     """Write line to a temp file first, then append to the target (append-only)."""
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -316,6 +347,8 @@ def build_event(args: argparse.Namespace, existing: list[dict[str, Any]]) -> dic
 def status_symbol(status: Any, reason: Any = None) -> str:
     text = str(status or "").strip().lower()
     reason_text = str(reason or "").strip()
+    if not text:
+        return "—"
     ok_set = {"ok", "passed", "pass", "success", "green", "✅", "✅ok"}
     warn_set = {"warn", "warning", "yellow", "skipped", "skip", "🟡", "🟡warn"}
     fail_set = {"fail", "failed", "error", "red", "blocked", "❌", "❌fail"}
@@ -327,7 +360,7 @@ def status_symbol(status: Any, reason: Any = None) -> str:
         return f"❌FAIL({reason_text})" if reason_text else "❌FAIL"
     if reason_text:
         return f"{status}({reason_text})"
-    return str(status or "unknown")
+    return str(status)
 
 
 def severity_symbol(severity: Any, message: Any = None) -> str:
@@ -339,7 +372,10 @@ def severity_symbol(severity: Any, message: Any = None) -> str:
         return f"🟡WARN({msg})" if msg else "🟡WARN"
     if text in {"info", "ok", "note"}:
         return f"✅OK({msg})" if msg else "✅OK"
-    return f"{severity}: {msg}" if msg else str(severity or "issue")
+    # Empty/unknown severity: never emit literal "issue"/"None".
+    if not text:
+        return ""
+    return f"{severity}: {msg}" if msg else str(severity)
 
 
 def format_duration(ms: int | None) -> str:
@@ -427,9 +463,10 @@ def phase_duration_ms(phase_events: list[dict[str, Any]]) -> int | None:
         elif etype == "phase.end":
             end_ts = event.get("timestamp")
     if start_ts and end_ts:
-        stamps = [e.get("timestamp") for e in phase_events if e.get("timestamp")]
-        effective_end = stamps[-1] if stamps else end_ts
-        return duration_ms_between(start_ts, effective_end)
+        # Closed phases end at the matching phase.end. Late events appended
+        # after closure are reported separately (late_event_stats) and never
+        # extend the closed duration (RET-21).
+        return duration_ms_between(start_ts, end_ts)
     # Fallback: first to last timestamp in the phase bucket.
     stamps = [e.get("timestamp") for e in phase_events if e.get("timestamp")]
     if len(stamps) >= 2:
@@ -437,38 +474,124 @@ def phase_duration_ms(phase_events: list[dict[str, Any]]) -> int | None:
     return None
 
 
+def late_event_stats(phase_events: list[dict[str, Any]]) -> dict[str, int]:
+    """Count events recorded after the closing phase.end (RET-21)."""
+    end_ts = None
+    for event in phase_events:
+        if event.get("type") == "phase.end":
+            end_ts = event.get("timestamp")
+    if not end_ts:
+        return {"lateEventCount": 0, "lateEventSpanMs": 0}
+    late_stamps = []
+    seen_end = False
+    for event in phase_events:
+        if event.get("type") == "phase.end" and not seen_end:
+            seen_end = True
+            continue
+        if seen_end and event.get("timestamp"):
+            late_stamps.append(event["timestamp"])
+    if not late_stamps:
+        return {"lateEventCount": 0, "lateEventSpanMs": 0}
+    span = duration_ms_between(end_ts, late_stamps[-1]) or 0
+    return {"lateEventCount": len(late_stamps), "lateEventSpanMs": span}
+
+
+def attempt_invocations(phase_events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Per-attempt invocation view: attempt, status, durationMs (RET-22)."""
+    invocations: list[dict[str, Any]] = []
+    for attempt in split_phase_attempts(phase_events):
+        events_in = attempt.get("events") or []
+        start_ts = None
+        end_ts = None
+        status = None
+        for event in events_in:
+            if event.get("type") == "phase.start" and start_ts is None:
+                start_ts = event.get("timestamp")
+            elif event.get("type") == "phase.end":
+                end_ts = event.get("timestamp")
+                status = event.get("status", status)
+        duration = None
+        if start_ts and end_ts:
+            duration = duration_ms_between(start_ts, end_ts)
+        invocations.append(
+            {
+                "attempt": attempt.get("attempt"),
+                "status": status,
+                "durationMs": duration,
+            }
+        )
+    return invocations
+
+
+def canonical_phase_timing(phase_events: list[dict[str, Any]]) -> dict[str, Any]:
+    """Single reducer for every duration view (RET-20).
+
+    activeExecutionMs: phase.start → matching phase.end (closed contract).
+    wallClockSpanMs: first → last timestamp in the bucket, late events included.
+    """
+    stamps = [e.get("timestamp") for e in phase_events if e.get("timestamp")]
+    active = phase_duration_ms(phase_events)
+    late = late_event_stats(phase_events)
+    wall = duration_ms_between(stamps[0], stamps[-1]) if len(stamps) >= 2 else active
+    return {
+        "activeExecutionMs": active,
+        "wallClockSpanMs": wall,
+        "lateEventCount": late["lateEventCount"],
+        "lateEventSpanMs": late["lateEventSpanMs"],
+    }
+
+
 def render_command_block(commands: list[dict[str, Any]]) -> list[str]:
     if not commands:
         return []
+
+    def command_display(event: dict[str, Any]) -> str:
+        cmd = str(event.get("command") or "").strip()
+        if cmd:
+            return cmd
+        return str(event.get("note") or "").strip()
+
     if len(commands) == 1:
         event = commands[0]
-        cmd = event.get("command") or ""
+        display = command_display(event)
+        if not display:
+            return []
         exit_code = event.get("exit_code")
         exit_text = "?" if exit_code is None else str(exit_code)
         duration = format_duration(
             int(event["duration_ms"]) if isinstance(event.get("duration_ms"), int) else None
         )
         note = str(event.get("note") or "").strip()
-        parts = [f"- command: `{cmd}`", f"exit={exit_text}", f"duration={duration}"]
-        if note:
+        parts = [f"- command: `{display}`", f"exit={exit_text}", f"duration={duration}"]
+        # Avoid duplicating note when it was already used as the display text.
+        if note and note != display:
             parts.append(f"note={note}")
         return [" · ".join(parts)]
 
-    lines = [
-        "",
-        "| 命令 | exit | duration | note |",
-        "| --- | ---: | ---: | --- |",
-    ]
+    rows: list[str] = []
     for event in commands:
-        cmd = str(event.get("command") or "").replace("|", "\\|")
+        display = command_display(event)
+        if not display:
+            continue
+        cmd = display.replace("|", "\\|")
         exit_code = event.get("exit_code")
         exit_text = "?" if exit_code is None else str(exit_code)
         duration = format_duration(
             int(event["duration_ms"]) if isinstance(event.get("duration_ms"), int) else None
         )
         note = str(event.get("note") or "").replace("|", "\\|")
-        lines.append(f"| `{cmd}` | {exit_text} | {duration} | {note} |")
-    lines.append("")
+        # If note was promoted to the command cell, leave the note column empty.
+        note_cell = "" if note == display else note
+        rows.append(f"| `{cmd}` | {exit_text} | {duration} | {note_cell} |")
+    if not rows:
+        return []
+    lines = [
+        "",
+        "| 命令 | exit | duration | note |",
+        "| --- | ---: | ---: | --- |",
+        *rows,
+        "",
+    ]
     return lines
 
 
@@ -491,23 +614,37 @@ def render_event_line(event: dict[str, Any]) -> list[str]:
         suffix = f" — {note}" if note else ""
         return [f"- phase.end @ {event.get('timestamp', '')}{suffix}"]
     if etype == "verification":
-        name = event.get("name") or "(unnamed)"
-        symbol = status_symbol(event.get("status"), event.get("reason") or event.get("note"))
+        note = str(event.get("note") or "").strip()
+        name = str(event.get("name") or "").strip() or (
+            note[:_NOTE_FALLBACK_MAXLEN] if note else ""
+        )
+        if not name:
+            return []
+        symbol = status_symbol(event.get("status"), event.get("reason"))
         return [f"- verification: {name} → {symbol}"]
     if etype == "decision":
-        decision = event.get("decision") or ""
-        reason = event.get("reason") or event.get("note") or ""
+        decision = str(event.get("decision") or "").strip()
+        reason = str(event.get("reason") or event.get("note") or "").strip()
+        if not decision:
+            return [f"- decision: {reason}"] if reason else []
         if reason:
             return [f"- decision: {decision} — {reason}"]
         return [f"- decision: {decision}"]
     if etype == "issue":
-        symbol = severity_symbol(event.get("severity"), event.get("message"))
+        note = str(event.get("note") or "").strip()
+        message = str(event.get("message") or "").strip() or note
+        symbol = severity_symbol(event.get("severity"), message)
+        if not symbol:
+            return [f"- issue: {note}"] if note else []
         code = event.get("code")
         prefix = f"[{code}] " if code else ""
         return [f"- issue: {prefix}{symbol}"]
     if etype == "artifact":
-        path = event.get("path") or ""
+        path = str(event.get("path") or "").strip()
+        note = str(event.get("note") or "").strip()
         kind = event.get("kind")
+        if not path:
+            return [f"- artifact: {note}"] if note else []
         if kind:
             return [f"- artifact: `{path}` ({kind})"]
         return [f"- artifact: `{path}`"]
@@ -647,12 +784,24 @@ def cmd_append(args: argparse.Namespace) -> int:
             as_json=as_json,
         )
     path = events_path(change_dir)
-    lock_path = change_dir / "events.ndjson.lock"
+    lock_path = path.with_name(path.name + ".lock")
 
     # §6.1/§6.2: 普通 append = 加锁 -> 追加一行 -> fsync -> 解锁，不 load 历史、不渲染。
     # new_event_id 用完整 uuid，无需扫描去重。锁覆盖 atomic_append_line 的
     # open/write/flush/fsync 全过程。
     event = build_event(args, [])
+    # Semantic hints (non-fatal): guide agents toward required fields.
+    if args.type == "issue" and not args.severity:
+        event["severity"] = "info"
+        print(
+            "warning: issue without --severity, defaulted to info",
+            file=sys.stderr,
+        )
+    if args.type == "verification" and (not args.name or not args.status):
+        print(
+            "warning: verification missing --name or --status",
+            file=sys.stderr,
+        )
     line = json.dumps(event, ensure_ascii=False, separators=(",", ":"))
     try:
         with event_file_lock(lock_path):