@hunter-harness/workflow-harness 0.2.60 → 0.2.62

package/harness/bundles/java/cursor/scripts/harness_context.py

@@ -810,10 +810,15 @@ def close_transition(
     artifact_entries: list[dict[str, Any]] = []
     for raw in artifacts or []:
         requested = Path(raw)
+        artifact_bases: list[Path] = []
+        for base in (project, contract_root, state_root):
+            resolved_base = base.resolve()
+            if resolved_base not in artifact_bases:
+                artifact_bases.append(resolved_base)
         candidates = (
             [requested]
             if requested.is_absolute()
-            else [project / requested, contract_root / requested]
+            else [base / requested for base in artifact_bases]
         )
         valid: list[Path] = []
         for candidate in candidates:
@@ -838,10 +843,11 @@ def close_transition(
                 "ok": False,
                 "code": "TRANSITION_ARTIFACT_INVALID",
                 "path": raw,
-                "acceptedBases": [str(project), str(contract_root)],
+                "acceptedBases": [str(base) for base in artifact_bases],
                 "examples": [
                     str(contract_root / "meta" / "plan-finalization.json"),
                     f".harness/changes/{change}/meta/plan-finalization.json",
+                    f".harness/state/changes/{change}/evidence/verification-ledger.json",
                     "meta/plan-finalization.json",
                 ],
             }

package/harness/bundles/java/cursor/scripts/harness_events.py

@@ -1077,6 +1077,11 @@ def split_phase_attempts(phase_events: list[dict[str, Any]]) -> list[dict[str, A
         "external.wait",
         "issue",
         "ci.wait",
+        # Preparation is intentionally outside the formal phase lifecycle.
+        # A blocked preflight must remain visible in the raw timeline without
+        # manufacturing an attempt or inflating the phase duration/count.
+        "phase.prepare.start",
+        "phase.prepare.end",
     }
     for event in phase_events:
         if event.get("type") == "phase.start":

package/harness/bundles/java/cursor/scripts/harness_events_sync.py

@@ -350,36 +350,97 @@ def _state_dir(change_dir: Path) -> Path:
     return Path(harness_paths.resolve_state_dir_for_contract(change_dir))
 
 
-def load_cursor(
+def _cursor_values(path: Path) -> tuple[int, int, bool]:
+    if not path.is_file():
+        return 0, 0, True
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return 0, 0, False
+    raw_acked = data.get("acked_lines") if isinstance(data, dict) else None
+    raw_base = data.get("producer_seq_base", 0) if isinstance(data, dict) else None
+    acked_valid = (
+        not isinstance(raw_acked, bool)
+        and isinstance(raw_acked, int)
+        and raw_acked >= 0
+    )
+    base_valid = (
+        not isinstance(raw_base, bool)
+        and isinstance(raw_base, int)
+        and raw_base >= 0
+    )
+    return (
+        raw_acked if acked_valid else 0,
+        raw_base if base_valid else 0,
+        acked_valid and base_valid,
+    )
+
+
+def _complete_line_count(path: Path) -> int:
+    if not path.is_file():
+        return 0
+    try:
+        data = path.read_bytes()
+    except OSError:
+        return 0
+    if not data:
+        return 0
+    return data.count(b"\n")
+
+
+def _initial_producer_seq_base(change_dir: Path) -> int:
+    """Keep producer sequence monotonic when a legacy stream becomes split-v1."""
+    state_dir = _state_dir(change_dir).resolve()
+    contract_dir = change_dir.resolve()
+    if state_dir == contract_dir:
+        return 0
+    legacy_acked, legacy_base, _ = _cursor_values(
+        contract_dir / "meta" / "events-sync-cursor.json"
+    )
+    legacy_lines = _complete_line_count(contract_dir / "events.ndjson")
+    return legacy_base + max(legacy_acked, legacy_lines)
+
+
+def load_cursor_state(
     change_dir: Path,
     *,
     maximum_lines: int | None = None,
     repair: bool = False,
-) -> int:
+) -> dict[str, int]:
     path = cursor_path(change_dir)
-    if not path.is_file():
-        return 0
-    valid = True
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        data = None
-        valid = False
-    raw = data.get("acked_lines") if isinstance(data, dict) else None
-    if isinstance(raw, bool) or not isinstance(raw, int) or raw < 0:
-        valid = False
-        value = 0
-    else:
-        value = raw
+    exists = path.is_file()
+    acked, producer_seq_base, valid = _cursor_values(path)
+    if not exists:
+        producer_seq_base = _initial_producer_seq_base(change_dir)
     if maximum_lines is not None:
         if maximum_lines < 0:
             raise ValueError("maximum_lines must be non-negative")
-        if value > maximum_lines:
+        if acked > maximum_lines:
+            acked = 0
             valid = False
-            value = 0
-    if not valid and repair:
-        save_cursor(change_dir, 0)
-    return value
+    if (not valid or not exists) and repair:
+        save_cursor(
+            change_dir,
+            acked,
+            producer_seq_base=producer_seq_base,
+        )
+    return {
+        "acked_lines": acked,
+        "producer_seq_base": producer_seq_base,
+    }
+
+
+def load_cursor(
+    change_dir: Path,
+    *,
+    maximum_lines: int | None = None,
+    repair: bool = False,
+) -> int:
+    return load_cursor_state(
+        change_dir,
+        maximum_lines=maximum_lines,
+        repair=repair,
+    )["acked_lines"]
 
 
 def _fsync_parent(path: Path) -> None:
@@ -392,14 +453,31 @@ def _fsync_parent(path: Path) -> None:
         os.close(descriptor)
 
 
-def save_cursor(change_dir: Path, acked_lines: int) -> None:
+def save_cursor(
+    change_dir: Path,
+    acked_lines: int,
+    *,
+    producer_seq_base: int | None = None,
+) -> None:
     if isinstance(acked_lines, bool) or not isinstance(acked_lines, int) or acked_lines < 0:
         raise ValueError("acked_lines must be a non-negative integer")
     path = cursor_path(change_dir)
+    if producer_seq_base is None:
+        _, producer_seq_base, _ = _cursor_values(path)
+    if (
+        isinstance(producer_seq_base, bool)
+        or not isinstance(producer_seq_base, int)
+        or producer_seq_base < 0
+    ):
+        raise ValueError("producer_seq_base must be a non-negative integer")
     path.parent.mkdir(parents=True, exist_ok=True)
     temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
     encoded = (
-        json.dumps({"schemaVersion": 1, "acked_lines": acked_lines}, indent=2) + "\n"
+        json.dumps({
+            "schemaVersion": 2,
+            "acked_lines": acked_lines,
+            "producer_seq_base": producer_seq_base,
+        }, indent=2) + "\n"
     ).encode("utf-8")
     descriptor = os.open(
         str(temporary), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600
@@ -489,6 +567,85 @@ def _event_lines_snapshot(events_file: Path) -> list[str]:
     return data.decode("utf-8-sig").splitlines()
 
 
+def _complete_stream_bytes(path: Path) -> bytes:
+    data = path.read_bytes() if path.is_file() else b""
+    if data and not data.endswith(b"\n"):
+        last_newline = data.rfind(b"\n")
+        data = b"" if last_newline < 0 else data[:last_newline + 1]
+    return data
+
+
+def _atomic_replace_bytes(path: Path, data: bytes) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
+    descriptor = os.open(
+        str(temporary), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600
+    )
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            descriptor = -1
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        _fsync_parent(path)
+    finally:
+        if descriptor >= 0:
+            os.close(descriptor)
+        try:
+            temporary.unlink()
+        except FileNotFoundError:
+            pass
+
+
+def _migrate_pending_legacy_stream(change_dir: Path) -> None:
+    """Prefix unsent colocated events before the first split-v1 state upload."""
+    contract_dir = change_dir.resolve()
+    state_dir = _state_dir(change_dir).resolve()
+    legacy_events = contract_dir / "events.ndjson"
+    target_events = state_dir / "events.ndjson"
+    target_cursor = state_dir / "meta" / "events-sync-cursor.json"
+    if state_dir == contract_dir or not legacy_events.is_file() or target_cursor.exists():
+        return
+    legacy_cursor = contract_dir / "meta" / "events-sync-cursor.json"
+    legacy_acked, _, _ = _cursor_values(legacy_cursor)
+    legacy_line_count = _complete_line_count(legacy_events)
+    if legacy_acked >= legacy_line_count:
+        return
+
+    locks = [
+        _CrossProcessLock(path.with_name(path.name + ".lock"))
+        for path in sorted((legacy_events, target_events), key=lambda item: str(item).casefold())
+    ]
+    for lock in locks:
+        lock.acquire(blocking=True)
+    try:
+        if target_cursor.exists() or not legacy_events.is_file():
+            return
+        legacy_data = _complete_stream_bytes(legacy_events)
+        target_data = _complete_stream_bytes(target_events)
+        if target_data.startswith(legacy_data):
+            merged = target_data
+        else:
+            merged = legacy_data + target_data
+        _atomic_replace_bytes(target_events, merged)
+
+        target_cursor.parent.mkdir(parents=True, exist_ok=True)
+        if legacy_cursor.is_file():
+            os.replace(legacy_cursor, target_cursor)
+        else:
+            save_cursor(change_dir, 0, producer_seq_base=0)
+
+        legacy_quarantine = contract_dir / "meta" / "events-sync-quarantine.ndjson"
+        target_quarantine = state_dir / "meta" / "events-sync-quarantine.ndjson"
+        if legacy_quarantine.is_file() and not target_quarantine.exists():
+            os.replace(legacy_quarantine, target_quarantine)
+        legacy_events.unlink()
+    finally:
+        for lock in reversed(locks):
+            lock.release()
+
+
 def sync_change(
     project: Path,
     change_dir: Path,
@@ -525,6 +682,7 @@ def sync_change(
     if heartbeat_only:
         return {"ok": True, "heartbeat": True, "run_id": rid, "change_key": resolved_key}
 
+    _migrate_pending_legacy_stream(change_dir)
     events_file = _state_dir(change_dir) / "events.ndjson"
     if not events_file.is_file():
         return {
@@ -536,11 +694,13 @@ def sync_change(
         }
 
     lines = _event_lines_snapshot(events_file)
-    acked = load_cursor(
+    cursor = load_cursor_state(
         change_dir,
         maximum_lines=len(lines),
         repair=True,
     )
+    acked = cursor["acked_lines"]
+    producer_seq_base = cursor["producer_seq_base"]
     pending_raw = lines[acked:]
     phase_plan = _workflow_plan(change_dir)
     uploaded = 0
@@ -571,7 +731,7 @@ def sync_change(
             event_id = str(event.get("id") or f"{resolved_key}:{line_number}")
             item: dict[str, Any] = {
                 "event_id": event_id,
-                "producer_seq": line_number,
+                "producer_seq": producer_seq_base + line_number,
                 "event_type": str(event.get("type") or "unknown"),
                 "occurred_at": str(event.get("timestamp") or event.get("ts") or client_time),
                 "payload": _event_payload(event, phase_plan),
@@ -664,7 +824,11 @@ def sync_change(
                 status="local_invalid",
             )
             quarantined += 1
-        save_cursor(change_dir, acked + chunk_start + len(raw_chunk))
+        save_cursor(
+            change_dir,
+            acked + chunk_start + len(raw_chunk),
+            producer_seq_base=producer_seq_base,
+        )
 
     return {
         "ok": True,
@@ -674,6 +838,7 @@ def sync_change(
         "quarantined": quarantined,
         "batch_size": min(MAX_BATCH_SIZE, len(pending_raw)),
         "acked_lines": len(lines),
+        "producer_seq_base": producer_seq_base,
         "server": last_result,
     }
 

package/harness/bundles/java/cursor/scripts/harness_ledger.py

@@ -1053,6 +1053,40 @@ def ledger_evidence_identity(ledger: dict[str, Any]) -> str:
     return "sha256:" + hashlib.sha256(canonical).hexdigest()
 
 
+def _immutable_change_base(
+    change_dir: Path,
+    project_root: Path,
+) -> str:
+    roots = [change_dir]
+    try:
+        state_root = harness_paths.resolve_state_dir_for_contract(
+            change_dir,
+            project_root,
+        )
+        if state_root.resolve() != change_dir.resolve():
+            roots.insert(0, state_root)
+    except (OSError, ValueError):
+        pass
+    for root in roots:
+        for relative in (
+            Path("meta") / "state-snapshot.json",
+            Path("state-snapshot.json"),
+        ):
+            path = root / relative
+            if not path.is_file():
+                continue
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8-sig"))
+            except (OSError, json.JSONDecodeError, TypeError):
+                continue
+            if not isinstance(payload, dict):
+                continue
+            value = str(payload.get("changeBase") or "").strip()
+            if value:
+                return value
+    return ""
+
+
 def migrate_ledger_for_write(
     change_dir: Path,
     ledger: dict[str, Any],
@@ -1089,6 +1123,15 @@ def migrate_ledger_for_write(
     if not _nonempty_str(resolved_base):
         resolved_base = ledger.get("baseCommit")
     if not _nonempty_str(resolved_base):
+        resolved_base = _immutable_change_base(change_dir, repo_root)
+    if not _nonempty_str(resolved_base):
+        if record_migration:
+            raise LedgerMigrationError(
+                "immutable change base is missing; recapture the Plan boundary "
+                "or pass an explicit --base-commit instead of using write-time HEAD"
+            )
+        # A genuinely new ledger establishes its identity at the first write.
+        # Existing ledgers are handled above and may never take this fallback.
         resolved_base = current_head
     resolved_diff = diff_hash
     if not _nonempty_str(resolved_diff):
@@ -2795,9 +2838,43 @@ def cmd_diff_hash(args: argparse.Namespace) -> int:
     repo_raw = getattr(args, "repo", None)
     repo = Path(repo_raw).expanduser().resolve() if repo_raw else Path.cwd().resolve()
     base = getattr(args, "base", None)
-    change_dir = getattr(args, "change_dir", None)
+    change_dir_raw = getattr(args, "change_dir", None)
     try:
-        diff_hash, meta = compute_diff_hash(repo, base=base, change_dir=change_dir)
+        change_dir = resolve_path(change_dir_raw) if change_dir_raw else None
+        if change_dir is not None and _contract_is_v2(change_dir):
+            resolved_base = str(base or "").strip()
+            if not resolved_base:
+                existing, _ = load_ledger(change_dir)
+                if isinstance(existing, dict):
+                    resolved_base = str(existing.get("baseCommit") or "").strip()
+            if not resolved_base:
+                resolved_base = _immutable_change_base(change_dir, repo)
+            if not resolved_base:
+                raise ValueError(
+                    "immutable change base is missing; capture the Plan boundary "
+                    "or pass --base"
+                )
+            detail = compute_ownership_diff(
+                repo,
+                base=resolved_base,
+                change_dir=change_dir,
+            )
+            payload = {
+                "ok": True,
+                "action": "diff-hash",
+                "identityScope": "change-ownership",
+                "algorithmVersion": "ownership-content-changeset-1",
+                "base": resolved_base,
+                "head": _git_text(repo, "rev-parse", "--verify", "HEAD"),
+                **detail,
+            }
+            emit_json(payload, as_json=as_json)
+            return 0
+        diff_hash, meta = compute_diff_hash(
+            repo,
+            base=base,
+            change_dir=str(change_dir) if change_dir is not None else None,
+        )
     except (OSError, RuntimeError, ValueError) as exc:
         return emit_error(str(exc), as_json=as_json)
     payload = {"ok": True, "action": "diff-hash", "diffHash": diff_hash}

package/harness/bundles/java/cursor/scripts/harness_profile.py

@@ -838,13 +838,20 @@ def _node_commands(project: Path) -> dict[str, Any]:
         "src/**/*.tsx",
         "test/**/*.ts",
         "test/**/*.tsx",
+        "tests/**/*.ts",
+        "tests/**/*.tsx",
         "packages/*/src/**/*.ts",
         "packages/*/src/**/*.tsx",
         "packages/*/test/**/*.ts",
         "packages/*/test/**/*.tsx",
+        "packages/*/tests/**/*.ts",
+        "packages/*/tests/**/*.tsx",
         "apps/*/src/**/*.ts",
         "apps/*/src/**/*.tsx",
         "apps/*/test/**/*.ts",
+        "apps/*/test/**/*.tsx",
+        "apps/*/tests/**/*.ts",
+        "apps/*/tests/**/*.tsx",
     ]
     # harness dogfood: canonical Python + .mjs sources feed npm run check (vitest
     # imports harness-test/scripts; smoke:pack runs sync-harness.mjs).

package/harness/bundles/java/cursor/scripts/harness_state.py

@@ -119,6 +119,10 @@ def capture_snapshot(
         "schemaVersion": SNAPSHOT_SCHEMA_VERSION,
         "generatedAt": now_iso(),
         "changeName": change_name,
+        # The first captured Git boundary is the immutable identity of the
+        # change.  Later phases may advance HEAD, but must never silently move
+        # the base and collapse the archive range.
+        "changeBase": base or "",
         "project": {"root": str(project.resolve())},
         "worktree": {"root": str(Path(worktree_root).resolve())},
         "git": {"base": base or "", "head": head or ""},
@@ -250,10 +254,25 @@ def capture_current_state(
     base: str = "",
     head: str = "HEAD",
 ) -> tuple[dict[str, Any], list[str]]:
-    resolved_head = _git(project, "rev-parse", head) or head
-    resolved_base = _git(project, "rev-parse", base) if base else ""
-    files = discover_segment_files(project, change_dir, base=resolved_base, head=resolved_head)
+    git_head = _git(project, "rev-parse", head)
+    resolved_head = git_head or head
     previous = load_snapshot(change_dir)
+    previous_git = previous.get("git") if isinstance(previous, dict) else None
+    previous_base = (
+        str(previous.get("changeBase") or "").strip()
+        if isinstance(previous, dict)
+        else ""
+    )
+    if not previous_base and isinstance(previous_git, dict):
+        previous_base = str(
+            previous_git.get("base") or previous_git.get("baseCommit") or ""
+        ).strip()
+    requested_base = _git(project, "rev-parse", base) if base else ""
+    # First capture establishes the boundary.  A later --base value is an
+    # observation hint only; changing the boundary requires the explicit
+    # archive range-adoption receipt.
+    resolved_base = previous_base or requested_base or git_head
+    files = discover_segment_files(project, change_dir, base=resolved_base, head=resolved_head)
     fresh = capture_snapshot(
         change_dir,
         change_name=change_name,