@hunter-harness/workflow-harness 0.2.9 → 0.2.11

package/harness/bundles/java/codex/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/codex/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/codex/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")
@@ -99,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:
@@ -179,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)
@@ -433,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:
@@ -443,6 +474,73 @@ 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 []
@@ -686,7 +784,7 @@ 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 的

package/harness/bundles/java/codex/scripts/harness_gate.py

@@ -32,6 +32,7 @@ if str(SCRIPTS_DIR) not in sys.path:
 import harness_change as hc  # noqa: E402
 import harness_events as he  # noqa: E402
 import harness_ledger as hl  # noqa: E402
+import harness_paths as hp  # noqa: E402
 import harness_workflow_policy as hwp  # noqa: E402
 import harness_test_guard as htg  # noqa: E402
 
@@ -751,7 +752,7 @@ def append_phase_event(
             if key not in event and value is not None:
                 event[key] = value
     line = json.dumps(event, ensure_ascii=False, separators=(",", ":"))
-    lock_path = change_dir / "events.ndjson.lock"
+    lock_path = events_file.with_name(events_file.name + ".lock")
     with he.event_file_lock(lock_path):
         he.atomic_append_line(events_file, line)
     rendered = False
@@ -1081,11 +1082,31 @@ def cmd_checkpoint(args: argparse.Namespace) -> int:
             as_json=as_json,
         )
     required_report = str(item.get("requiredReport") or "")
-    report_path = change_dir / required_report
-    if not required_report or not report_path.is_file() or report_path.stat().st_size == 0:
+    report_rel = Path(required_report)
+    if (
+        not required_report
+        or report_rel.is_absolute()
+        or ".." in report_rel.parts
+    ):
+        return emit_error(
+            "CHECKPOINT_REPORT_PATH_INVALID",
+            f"required report path is invalid: {required_report or '<unset>'}",
+            as_json=as_json,
+        )
+    state_dir = hp.resolve_state_dir_for_contract(change_dir, project)
+    report_candidates = [state_dir / report_rel]
+    if state_dir != change_dir:
+        # Compatibility fallback for split-v1 changes created before dynamic
+        # reports were routed to the state root.
+        report_candidates.append(change_dir / report_rel)
+    report_path = next(
+        (candidate for candidate in report_candidates if candidate.is_file()),
+        report_candidates[0],
+    )
+    if not report_path.is_file() or report_path.stat().st_size == 0:
         return emit_error(
             "CHECKPOINT_REPORT_MISSING",
-            f"required report is missing: {required_report or '<unset>'}",
+            f"required report is missing: {required_report}",
             as_json=as_json,
         )
     report_text = report_path.read_text(encoding="utf-8", errors="replace")