@hunter-harness/workflow-harness 0.2.26 → 0.2.28

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

@@ -51,12 +51,227 @@ _FOREIGN_PATTERNS = (
     re.compile(r"^\.harness/changes/([^/]+)(/|$)"),
     re.compile(r"^\.harness/state/changes/([^/]+)(/|$)"),
 )
+WORKTREE_LIFECYCLE_STATES = (
+    "REGISTERED",
+    "MATERIALIZED",
+    "AGENT_ATTACHED",
+    "ACTIVE",
+    "QUIESCING",
+    "AGENT_DETACHED",
+    "STATE_FINALIZED",
+    "REGISTRATION_REMOVED",
+    "RESIDUAL_CLEANED",
+    "RETIRED",
+)
 
 
 def now_iso() -> str:
     return dt.datetime.now().astimezone().isoformat(timespec="milliseconds")
 
 
+def _worktree_registrations(project_root: Path) -> dict[str, dict[str, Any]]:
+    proc = subprocess.run(
+        ["git", "worktree", "list", "--porcelain"],
+        cwd=str(project_root),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    registrations: dict[str, dict[str, Any]] = {}
+    current: dict[str, Any] | None = None
+    for line in proc.stdout.splitlines() if proc.returncode == 0 else []:
+        if line.startswith("worktree "):
+            path = str(Path(line.removeprefix("worktree ")).resolve())
+            current = {"path": path, "branch": None, "head": None}
+            registrations[path] = current
+        elif current is not None and line.startswith("branch "):
+            current["branch"] = line.removeprefix("branch ")
+        elif current is not None and line.startswith("HEAD "):
+            current["head"] = line.removeprefix("HEAD ")
+    return registrations
+
+
+def _active_capsules_for_root(
+    project_root: Path,
+    target_root: Path,
+    change_dir: Path | None,
+) -> list[dict[str, Any]]:
+    candidates: list[Path] = []
+    change_dirs = [change_dir.resolve()] if change_dir is not None else []
+    if not change_dirs:
+        for root in (
+            project_root / ".harness" / "changes",
+            project_root / ".harness" / "state" / "changes",
+        ):
+            if root.is_dir():
+                change_dirs.extend(path for path in root.iterdir() if path.is_dir())
+    for root in change_dirs:
+        for capsule_root in (
+            root / "runtime" / "phase-context",
+            root / "phase-context",
+        ):
+            if capsule_root.is_dir():
+                candidates.extend(sorted(capsule_root.glob("*.json")))
+    active: list[dict[str, Any]] = []
+    for path in candidates:
+        try:
+            capsule = json.loads(path.read_text(encoding="utf-8-sig"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        if not isinstance(capsule, dict):
+            continue
+        raw_root = str(capsule.get("executionRoot") or "").strip()
+        if not raw_root:
+            continue
+        try:
+            same_root = Path(raw_root).resolve() == target_root
+        except OSError:
+            same_root = False
+        transaction = capsule.get("closeTransaction")
+        transaction_status = (
+            str(transaction.get("status") or "").upper()
+            if isinstance(transaction, dict)
+            else ""
+        )
+        closed = transaction_status == "CLOSED" or bool(
+            capsule.get("closedAt") and capsule.get("closeStatus")
+        )
+        if same_root and not closed:
+            active.append(
+                {
+                    "path": str(path),
+                    "phase": capsule.get("phase"),
+                    "runId": capsule.get("runId"),
+                    "transactionStatus": transaction_status or "OPEN",
+                }
+            )
+    return active
+
+
+def evaluate_worktree_retirement(
+    project_root: Path,
+    target_root: Path,
+    *,
+    change_dir: Path | None = None,
+    agent_root: Path | None = None,
+    junction_dependencies: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Journal a unified, read-only preflight for safe worktree retirement."""
+    project_root = project_root.resolve()
+    target_root = target_root.resolve()
+    registrations = _worktree_registrations(project_root)
+    registration = registrations.get(str(target_root))
+    active_capsules = _active_capsules_for_root(
+        project_root,
+        target_root,
+        change_dir,
+    )
+    if junction_dependencies is None:
+        junction_path = (
+            project_root
+            / ".harness"
+            / "config"
+            / "junction-dependencies.json"
+        )
+        try:
+            loaded = json.loads(junction_path.read_text(encoding="utf-8-sig"))
+        except (OSError, json.JSONDecodeError):
+            loaded = []
+        junction_dependencies = loaded if isinstance(loaded, list) else []
+    matching_junctions = []
+    for item in junction_dependencies:
+        if not isinstance(item, dict):
+            continue
+        try:
+            matches = Path(str(item.get("target") or "")).resolve() == target_root
+        except OSError:
+            matches = False
+        if matches:
+            matching_junctions.append(item)
+    attached = False
+    if agent_root is not None:
+        try:
+            resolved_agent = agent_root.resolve()
+            attached = (
+                resolved_agent == target_root
+                or target_root in resolved_agent.parents
+            )
+        except OSError:
+            attached = True
+    blockers: list[dict[str, Any]] = []
+    if active_capsules:
+        blockers.append(
+            {
+                "code": "ACTIVE_PHASE_CAPSULE",
+                "message": "phase capsules still reference the worktree",
+                "capsules": active_capsules,
+            }
+        )
+    if attached:
+        blockers.append(
+            {
+                "code": "AGENT_STILL_ATTACHED",
+                "message": "Agent root/cwd still points into the worktree",
+                "agentRoot": str(agent_root.resolve()) if agent_root else None,
+            }
+        )
+    if matching_junctions:
+        blockers.append(
+            {
+                "code": "JUNCTION_DEPENDENCY_ACTIVE",
+                "message": "junction dependencies must be removed or migrated",
+                "junctions": matching_junctions,
+            }
+        )
+    receipt = {
+        "schemaVersion": 1,
+        "lifecycleId": hashlib.sha256(
+            str(target_root).encode("utf-8")
+        ).hexdigest()[:20],
+        "projectRoot": str(project_root),
+        "targetRoot": str(target_root),
+        "state": "ACTIVE" if blockers else "QUIESCING",
+        "allowedStates": list(WORKTREE_LIFECYCLE_STATES),
+        "registration": registration,
+        "diskPathPresent": target_root.exists(),
+        "agentAttached": attached,
+        "activeCapsules": active_capsules,
+        "junctionDependencies": matching_junctions,
+        "blockers": blockers,
+        "ok": not blockers,
+        "code": (
+            "WORKTREE_RETIREMENT_READY"
+            if not blockers
+            else "WORKTREE_RETIREMENT_BLOCKED"
+        ),
+        "updatedAt": now_iso(),
+    }
+    receipt_path = (
+        project_root
+        / ".harness"
+        / "runtime"
+        / "worktree-lifecycle"
+        / f"{receipt['lifecycleId']}.json"
+    )
+    receipt_path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = receipt_path.with_name(
+        f".{receipt_path.name}.{os.getpid()}.tmp"
+    )
+    try:
+        temporary.write_text(
+            json.dumps(receipt, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+            newline="\n",
+        )
+        os.replace(temporary, receipt_path)
+    finally:
+        temporary.unlink(missing_ok=True)
+    receipt["receiptPath"] = str(receipt_path)
+    return receipt
+
+
 def _split_verify_command(raw: str, *, platform: str = sys.platform) -> list[str]:
     # Harness profile/CLI commands use one portable quoting contract. Keep
     # POSIX tokenization on Windows too; executable normalization happens later.
@@ -243,6 +458,26 @@ def _sanitize(value: str) -> str:
     return re.sub(r"[^A-Za-z0-9._-]+", "-", value).strip("-") or "txn"
 
 
+def _compact_transaction_id(change_id: str, run_id: str, *, limit: int = 48) -> str:
+    readable = f"{_sanitize(change_id)}-{_sanitize(run_id)}"
+    if len(readable) <= limit:
+        return readable
+    digest = hashlib.sha256(readable.encode("utf-8")).hexdigest()[:12]
+    prefix = _sanitize(change_id)[: max(8, limit - len(digest) - 1)]
+    return f"{prefix}-{digest}"
+
+
+def default_temp_root(project_root: Path) -> Path:
+    """Use a deliberately short Windows worktree root to protect MAX_PATH."""
+    configured = os.environ.get("HUNTER_HARNESS_INTEGRATION_ROOT")
+    if configured:
+        return Path(configured).expanduser().resolve()
+    resolved = Path(project_root).resolve()
+    if os.name == "nt" and resolved.drive:
+        return Path(resolved.drive + os.sep) / "hh-int"
+    return resolved / ".harness" / "runtime" / "i"
+
+
 def journal_dir(project_root: Path, transaction_id: str) -> Path:
     return (
         Path(project_root)
@@ -419,7 +654,7 @@ class IntegrationTransaction:
         self.feature_branch = feature_branch
         self.temp_root = Path(temp_root).resolve()
         self.runner = runner or GitRunner()
-        self.transaction_id = f"{_sanitize(change_id)}-{_sanitize(run_id)}"
+        self.transaction_id = _compact_transaction_id(change_id, run_id)
         self.temp_branch = f"harness/integration/{self.transaction_id}"
 
     # ------------------------------------------------------------- journal
@@ -1249,6 +1484,23 @@ class IntegrationTransaction:
             raise CleanupRefusedError(
                 f"refusing to clean unregistered worktree path: {resolved}"
             )
+        lifecycle = evaluate_worktree_retirement(
+            self.project_root,
+            resolved,
+            agent_root=(
+                Path(os.environ["HUNTER_HARNESS_AGENT_ROOT"])
+                if os.environ.get("HUNTER_HARNESS_AGENT_ROOT")
+                else None
+            ),
+        )
+        if not lifecycle.get("ok"):
+            codes = ", ".join(
+                str(item.get("code") or "UNKNOWN")
+                for item in lifecycle.get("blockers") or []
+            )
+            raise CleanupRefusedError(
+                f"worktree lifecycle blocks cleanup: {codes}"
+            )
 
         heavy_removed: list[str] = []
         heavy_failures: list[dict[str, str]] = []
@@ -1592,13 +1844,18 @@ class IntegrationTransaction:
 
 
 def _txn_from_args(args: argparse.Namespace) -> IntegrationTransaction:
+    project_root = Path.cwd()
     return IntegrationTransaction(
-        project_root=Path.cwd(),
+        project_root=project_root,
         change_id=args.change,
         run_id=args.run_id,
         target_branch=args.target_branch,
         feature_branch=args.feature_branch,
-        temp_root=Path(args.temp_root),
+        temp_root=(
+            Path(args.temp_root)
+            if getattr(args, "temp_root", None)
+            else default_temp_root(project_root)
+        ),
     )
 
 
@@ -1693,7 +1950,7 @@ def build_parser() -> argparse.ArgumentParser:
         p.add_argument("--run-id", required=True)
         p.add_argument("--target-branch", default="main")
         p.add_argument("--feature-branch", required=True)
-        p.add_argument("--temp-root", required=True)
+        p.add_argument("--temp-root")
         p.set_defaults(func=func)
 
     add("preflight", cmd_preflight)
@@ -1710,7 +1967,7 @@ def build_parser() -> argparse.ArgumentParser:
     p_journal.add_argument("--run-id", required=True)
     p_journal.add_argument("--target-branch", default="main")
     p_journal.add_argument("--feature-branch", required=True)
-    p_journal.add_argument("--temp-root", required=True)
+    p_journal.add_argument("--temp-root")
     p_journal.add_argument(
         "--verbose",
         action="store_true",
@@ -1723,7 +1980,7 @@ def build_parser() -> argparse.ArgumentParser:
     p_verify.add_argument("--run-id", required=True)
     p_verify.add_argument("--target-branch", default="main")
     p_verify.add_argument("--feature-branch", required=True)
-    p_verify.add_argument("--temp-root", required=True)
+    p_verify.add_argument("--temp-root")
     p_verify.add_argument("--command", action="append")
     p_verify.add_argument(
         "--timeout-seconds",