@hunter-harness/workflow-harness 0.2.23 → 0.2.25

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

@@ -900,10 +900,22 @@ def resolve_product_archive_identity(
         or ledger.get("finalCommit")
         or ""
     )
+    feature_merge = str(
+        ledger.get("featureMergeHash")
+        or ledger.get("mergeFinalHash")
+        or product
+    ).strip()
+    code, current_head, _ = git_run(project_root, "rev-parse", "HEAD")
+    release_tip = str(
+        ledger.get("releaseTipHash")
+        or (current_head if code == 0 else "")
+        or ledger.get("archiveCommit")
+        or product
+    ).strip()
     archive = (
         archive_commit
         or ledger.get("archiveCommit")
-        or ledger.get("finalCommit")
+        or release_tip
         or product
     )
     tree = str(ledger.get("productTreeHash") or "")
@@ -930,6 +942,8 @@ def resolve_product_archive_identity(
             tree = hashlib.sha256(b"fixture-no-product-tree").hexdigest()
     identity = {
         "productCommit": str(product),
+        "featureMergeHash": feature_merge,
+        "releaseTipHash": release_tip,
         "productTreeHash": str(tree),
         "archiveCommit": str(archive),
         "productTreeHashTruncated": bool(tree_meta.get("truncated")),
@@ -1659,6 +1673,7 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
 
     run = failures = errors = skipped = 0
     passed_count: int | None = None
+    deselected = 0
     pass_rate: Any = None
     source = "committed"
     counted = False
@@ -1675,6 +1690,7 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
             "failures",
             "errors",
             "skipped",
+            "deselected",
         )
     ):
         if "total" in metrics:
@@ -1690,6 +1706,7 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
         failures = int(metrics.get("failed", metrics.get("failures", 0)) or 0)
         errors = int(metrics.get("errors", 0) or 0)
         skipped = int(metrics.get("skipped", 0) or 0)
+        deselected = int(metrics.get("deselected", 0) or 0)
         if "passed" in metrics:
             passed_count = int(metrics.get("passed", 0) or 0)
         pass_rate = metrics.get("passRate")
@@ -1708,6 +1725,7 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
         failures = int(evidence.get("failures", unit.get("failures", 0)) or 0)
         errors = int(evidence.get("errors", unit.get("errors", 0)) or 0)
         skipped = int(evidence.get("skipped", unit.get("skipped", 0)) or 0)
+        deselected = int(evidence.get("deselected", unit.get("deselected", 0)) or 0)
         pass_rate = evidence.get("passRate") or unit.get("passRate")
         source = "committed"
         counted = run > 0 or failures > 0 or errors > 0 or skipped > 0
@@ -1729,6 +1747,7 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
         failures = int(unit.get("failures", 0) or 0)
         errors = int(unit.get("errors", 0) or 0)
         skipped = int(unit.get("skipped", 0) or 0)
+        deselected = int(unit.get("deselected", 0) or 0)
         pass_rate = unit.get("passRate")
         source = "committed"
 
@@ -1755,6 +1774,7 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
         "failures": int(failures or 0),
         "errors": int(errors or 0),
         "skipped": int(skipped or 0),
+        "deselected": int(deselected or 0),
         "passRate": pass_rate if pass_rate is not None else NOT_AVAILABLE,
         "source": source,
     }
@@ -1771,10 +1791,12 @@ def _ledger_api_tests(
     empty = {
         "status": "NOT_RUN",
         "total": 0,
+        "executed": 0,
         "passed": 0,
         "failed": 0,
         "blocked": 0,
         "passRate": NOT_AVAILABLE,
+        "executionRate": NOT_AVAILABLE,
         "source": "not-run",
     }
     if not ledger:
@@ -1853,18 +1875,19 @@ def _ledger_api_tests(
         pass_rate = api.get("passRate")
         source = "committed"
 
-    if pass_rate is None and total > 0:
-        pass_rate = f"{passed / total:.0%}"
-    elif pass_rate is None:
-        pass_rate = NOT_AVAILABLE
+    executed = passed + failed
+    pass_rate = f"{passed / executed:.0%}" if executed > 0 else NOT_AVAILABLE
+    execution_rate = f"{executed / total:.0%}" if total > 0 else NOT_AVAILABLE
 
     return {
         "status": status,
         "total": int(total or 0),
+        "executed": int(executed or 0),
         "passed": int(passed or 0),
         "failed": int(failed or 0),
         "blocked": int(blocked or 0),
-        "passRate": pass_rate if pass_rate is not None else NOT_AVAILABLE,
+        "passRate": pass_rate,
+        "executionRate": execution_rate,
         "source": source,
     }
 
@@ -1937,13 +1960,16 @@ def _typed_test_metrics(entry: dict[str, Any], *, total_key: str) -> dict[str, A
     total = int(metrics.get(total_key, 0) or 0)
     passed = int(metrics.get("passed", 0) or 0)
     failed = int(metrics.get("failed", 0) or 0)
+    executed = passed + failed
     status = str(entry.get("status") or "").upper() or "NOT_RUN"
     out: dict[str, Any] = {
         "status": status,
         "total": total,
+        "executed": executed,
         "passed": passed,
         "failed": failed,
-        "passRate": f"{passed / total:.0%}" if total > 0 else NOT_AVAILABLE,
+        "passRate": f"{passed / executed:.0%}" if executed > 0 else NOT_AVAILABLE,
+        "executionRate": f"{executed / total:.0%}" if total > 0 else NOT_AVAILABLE,
         "source": "committed" if total > 0 else "not-run",
     }
     if "blocked" in metrics:
@@ -1980,6 +2006,17 @@ def build_verification_projection(
     browser_e2e = validations.get("browserE2E")
     if isinstance(browser_e2e, dict):
         projection["browserE2E"] = _typed_test_metrics(browser_e2e, total_key="total")
+    performance = validations.get("performance")
+    if isinstance(performance, dict):
+        projection["performance"] = {
+            "status": str(performance.get("status") or "NOT_RUN").upper(),
+            "metrics": _deepcopy_json(
+                performance.get("metrics")
+                if isinstance(performance.get("metrics"), dict)
+                else {}
+            ),
+            "source": "committed",
+        }
     return projection
 
 
@@ -2142,14 +2179,25 @@ def _verification_checks_from_events(
     return checks
 
 
-def _artifacts_from_events(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+def _artifacts_from_events(
+    events: list[dict[str, Any]],
+    *,
+    change_dir: Path | None = None,
+) -> list[dict[str, Any]]:
     out: list[dict[str, Any]] = []
     for e in events:
         if e.get("type") != "artifact":
             continue
+        raw_path = str(e.get("path") or "")
+        archived_path = raw_path
+        if change_dir is not None and raw_path:
+            product_copy = change_dir / "artifacts" / "product" / raw_path
+            if not (change_dir / raw_path).is_file() and product_copy.is_file():
+                archived_path = product_copy.relative_to(change_dir).as_posix()
         out.append(
             {
-                "path": e.get("path") or "",
+                "path": archived_path,
+                **({"sourcePath": raw_path} if archived_path != raw_path else {}),
                 "kind": e.get("kind") or "",
                 "phase": e.get("phase") or "",
             }
@@ -2882,7 +2930,7 @@ def collect_summary_data(
             "dbCompatibility": db,
             "coverageDisplay": coverage,
         }
-        for typed_key in ("apiContract", "browserE2E"):
+        for typed_key in ("apiContract", "browserE2E", "performance"):
             if typed_key in projection:
                 data["verification"][typed_key] = projection[typed_key]
         if ci_metrics is not None:
@@ -2982,6 +3030,8 @@ def collect_summary_data(
     if not for_replay:
         identity = resolve_product_archive_identity(change_dir, project=project)
         data["productCommit"] = identity.get("productCommit") or data.get("finalCommit")
+        data["featureMergeHash"] = identity.get("featureMergeHash") or data.get("finalCommit")
+        data["releaseTipHash"] = identity.get("releaseTipHash") or data.get("archiveCommit")
         data["productTreeHash"] = identity.get("productTreeHash")
         data["archiveCommit"] = identity.get("archiveCommit") or data.get("finalCommit")
         data["changeIdentity"] = identity
@@ -3049,6 +3099,8 @@ def collect_summary_data(
     data["gitFacts"] = {
         "baseCommit": data.get("baseCommit") or "",
         "finalCommit": data.get("finalCommit") or "",
+        "featureMergeHash": data.get("featureMergeHash") or "",
+        "releaseTipHash": data.get("releaseTipHash") or "",
         "filesChanged": int(diff_for_facts.get("filesChanged") or 0),
         "insertions": int(diff_for_facts.get("insertions") or 0),
         "deletions": int(diff_for_facts.get("deletions") or 0),
@@ -3069,7 +3121,9 @@ def collect_summary_data(
     if not isinstance(data.get("artifacts"), list):
         data["artifacts"] = []
     if not for_replay:
-        data["artifacts"] = _artifacts_from_events(projected_events)
+        data["artifacts"] = _artifacts_from_events(
+            projected_events, change_dir=change_dir
+        )
 
     data["reviewSummary"] = _review_summary(
         change_dir,
@@ -3151,7 +3205,9 @@ def collect_summary_data(
         # Cannot invent commands
         pass
     verification_checks = _verification_checks_from_events(projected_events, ledger)
-    pipeline_artifacts = _artifacts_from_events(projected_events)
+    pipeline_artifacts = _artifacts_from_events(
+        projected_events, change_dir=change_dir
+    )
     if not sources:
         sources = [NOT_AVAILABLE]
 
@@ -4012,6 +4068,7 @@ def artifact_preflight(change_dir: Path) -> dict[str, Any]:
     if not events_p.is_file():
         return {"ok": True, "items": [], "blocking": []}
     change_id = change_dir.name
+    project_root = find_project_root(change_dir)
     for line in events_p.read_text(encoding="utf-8").splitlines():
         try:
             event = json.loads(line)
@@ -4058,16 +4115,56 @@ def artifact_preflight(change_dir: Path) -> dict[str, Any]:
                 "correction": f"append correction --target-event-id {event_id} --target-field path --new-value-json \"{canonical}\"",
             })
             continue
-        # Change-relative path: OK.
-        items.append({
+        change_file = change_dir / path
+        if change_file.is_file():
+            items.append({
+                "eventId": event_id,
+                "category": "file-backed",
+                "path": path,
+                "exists": True,
+            })
+            continue
+        repository_file = project_root / path
+        if repository_file.is_file():
+            items.append({
+                "eventId": event_id,
+                "category": "repository-file",
+                "path": path,
+                "archivePath": f"artifacts/product/{path}",
+                "exists": True,
+            })
+            continue
+        item = {
             "eventId": event_id,
-            "category": "file-backed",
+            "category": "blocking",
             "path": path,
-            "exists": (change_dir / path).is_file(),
-        })
+            "kind": kind,
+            "reason": "artifact file not found in change or project root",
+        }
+        items.append(item)
+        blocking.append(item)
     return {"ok": not blocking, "items": items, "blocking": blocking}
 
 
+def materialize_repository_artifacts(change_dir: Path) -> dict[str, Any]:
+    """Copy project-root business artifacts into the immutable archive namespace."""
+    change_dir = change_dir.resolve()
+    project_root = find_project_root(change_dir)
+    preflight = artifact_preflight(change_dir)
+    copied: list[str] = []
+    for item in preflight.get("items") or []:
+        if item.get("category") != "repository-file":
+            continue
+        source = (project_root / str(item["path"])).resolve()
+        target = (change_dir / str(item["archivePath"])).resolve()
+        if not source.is_relative_to(project_root) or not target.is_relative_to(change_dir):
+            raise ValueError(f"artifact materialization escaped boundary: {item['path']}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+        copied.append(target.relative_to(change_dir).as_posix())
+    return {"ok": True, "copied": sorted(copied)}
+
+
 def run_knowledge_poststeps(project_root: Path) -> dict[str, Any]:
     results: dict[str, Any] = {"ran": False, "steps": [], "warnings": []}
     if not KNOWLEDGE_SCRIPT.is_file():
@@ -4343,6 +4440,16 @@ def cmd_finalize(
         warnings.append(f"cleanup failed: {exc}")
         payload["steps"]["cleanup"] = {"ok": False, "error": str(exc)}
 
+    # Product/business artifacts may live at repository-relative paths. Freeze
+    # byte-for-byte copies inside the staged archive before either manifest.
+    try:
+        materialized = materialize_repository_artifacts(work_dir)
+        payload["steps"]["artifact_materialization"] = materialized
+    except (OSError, ValueError) as exc:
+        payload["error"] = f"artifact materialization failed: {exc}"
+        _restore_finalize_failure()
+        return 1, payload
+
     # --- 1. before-manifest ---
     before_path = work_dir / "evidence" / "archive-manifest-before.json"
     try:

package/harness/bundles/java/codebuddy/scripts/harness_deploy.py

@@ -16,6 +16,7 @@ import re
 import shutil
 import subprocess
 import sys
+import time
 import uuid
 from pathlib import Path
 from typing import Any, Iterable
@@ -38,6 +39,7 @@ HEADING_RE = re.compile(r"^(#{2,6})\s+(.+?)\s*$")
 FRAGMENT_HINT_RE = re.compile(r"^>\s*片段：\[\[shared/[^\]]+\]\]\s*.*$")
 
 BUILD_MARKER = ".harness-build.json"
+_REPLACE_RETRY_DELAYS_SECONDS = (0.05, 0.1, 0.2, 0.4, 0.8)
 # Install-side managed manifests record which files a prior install owned, so a
 # later conservative install can delete removed managed files while preserving
 # user-owned files (design §3.8 要点4). Skills manifest lives in the skills
@@ -76,6 +78,23 @@ def now_iso() -> str:
     return dt.datetime.now().astimezone().isoformat(timespec="seconds")
 
 
+def replace_with_retry(source: Path, target: Path) -> None:
+    """Bounded retry for transient directory locks during atomic swaps.
+
+    Windows indexers and antivirus scanners may briefly hold a newly generated
+    bundle directory. Retrying only ``PermissionError`` keeps real path and
+    contract failures fail-fast while avoiding an expensive full bundle rerun.
+    """
+    for attempt in range(len(_REPLACE_RETRY_DELAYS_SECONDS) + 1):
+        try:
+            os.replace(source, target)
+            return
+        except PermissionError:
+            if attempt >= len(_REPLACE_RETRY_DELAYS_SECONDS):
+                raise
+            time.sleep(_REPLACE_RETRY_DELAYS_SECONDS[attempt])
+
+
 def emit_json(payload: dict[str, Any], *, ok: bool = True) -> int:
     print(json.dumps(payload, ensure_ascii=False, indent=2))
     return 0 if ok else 1
@@ -596,15 +615,15 @@ def cmd_build(
     if out_dir.exists():
         if (out_dir / BUILD_MARKER).is_file():
             old_backup = out_dir.parent / f".{out_dir.name}.old-{uuid.uuid4().hex[:8]}"
-            os.replace(out_dir, old_backup)
+            replace_with_retry(out_dir, old_backup)
         else:
             shutil.rmtree(staging, ignore_errors=True)
             raise ValueError(f"refusing to overwrite unmarked out_dir: {out_dir}")
     try:
-        os.replace(staging, out_dir)
+        replace_with_retry(staging, out_dir)
     except OSError:
         if old_backup is not None and old_backup.exists():
-            os.replace(old_backup, out_dir)
+            replace_with_retry(old_backup, out_dir)
         raise
     if old_backup is not None:
         shutil.rmtree(old_backup, ignore_errors=True)

package/harness/bundles/java/codebuddy/scripts/harness_integration.py

@@ -257,6 +257,42 @@ def journal_path(project_root: Path, transaction_id: str) -> Path:
     return journal_dir(project_root, transaction_id) / "journal.json"
 
 
+def _write_verify_log(
+    project_root: Path,
+    transaction_id: str,
+    index: int,
+    *,
+    command: Sequence[str],
+    resolved_command: Sequence[str],
+    started: dt.datetime,
+    finished: dt.datetime,
+    exit_code: int | None,
+    stdout: str | bytes | None = None,
+    stderr: str | bytes | None = None,
+    error: str | None = None,
+) -> str:
+    def as_text(value: str | bytes | None) -> str:
+        if isinstance(value, bytes):
+            return value.decode("utf-8", errors="replace")
+        return value or ""
+
+    path = journal_dir(project_root, transaction_id) / "logs" / f"verify-{index + 1}.log"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = [
+        f"command: {json.dumps(list(command), ensure_ascii=False)}",
+        f"resolvedCommand: {json.dumps(list(resolved_command), ensure_ascii=False)}",
+        f"startedAt: {started.isoformat(timespec='milliseconds')}",
+        f"finishedAt: {finished.isoformat(timespec='milliseconds')}",
+        f"durationMs: {int((finished - started).total_seconds() * 1000)}",
+        f"exitCode: {exit_code if exit_code is not None else 'null'}",
+    ]
+    if error:
+        lines.append(f"error: {error}")
+    lines.extend(["--- stdout ---", as_text(stdout), "--- stderr ---", as_text(stderr)])
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
+    return path.relative_to(project_root).as_posix()
+
+
 def load_journal(project_root: Path, transaction_id: str) -> dict[str, Any]:
     path = journal_path(project_root, transaction_id)
     if not path.is_file():
@@ -965,7 +1001,7 @@ class IntegrationTransaction:
                 )
             intg_root = Path(journal["integrationRoot"]).resolve()
             results: list[dict[str, Any]] = []
-            for command in commands:
+            for index, command in enumerate(commands):
                 executable_command = _normalize_verify_command(command)
                 started = dt.datetime.now().astimezone()
                 try:
@@ -979,8 +1015,21 @@ class IntegrationTransaction:
                         check=False,
                         timeout=timeout_seconds,
                     )
-                except subprocess.TimeoutExpired:
+                except subprocess.TimeoutExpired as exc:
                     finished = dt.datetime.now().astimezone()
+                    log_path = _write_verify_log(
+                        self.project_root,
+                        self.transaction_id,
+                        index,
+                        command=command,
+                        resolved_command=executable_command,
+                        started=started,
+                        finished=finished,
+                        exit_code=None,
+                        stdout=exc.stdout,
+                        stderr=exc.stderr,
+                        error=f"timed out after {timeout_seconds}s",
+                    )
                     results.append(
                         {
                             "command": list(command),
@@ -993,6 +1042,7 @@ class IntegrationTransaction:
                             "durationMs": int(
                                 (finished - started).total_seconds() * 1000
                             ),
+                            "logPath": log_path,
                         }
                     )
                     journal["verifyResults"] = results
@@ -1002,6 +1052,17 @@ class IntegrationTransaction:
                     )
                 except FileNotFoundError as exc:
                     finished = dt.datetime.now().astimezone()
+                    log_path = _write_verify_log(
+                        self.project_root,
+                        self.transaction_id,
+                        index,
+                        command=command,
+                        resolved_command=executable_command,
+                        started=started,
+                        finished=finished,
+                        exit_code=None,
+                        error=str(exc),
+                    )
                     results.append(
                         {
                             "command": list(command),
@@ -1013,6 +1074,7 @@ class IntegrationTransaction:
                             "durationMs": int(
                                 (finished - started).total_seconds() * 1000
                             ),
+                            "logPath": log_path,
                         }
                     )
                     journal["verifyResults"] = results
@@ -1021,6 +1083,18 @@ class IntegrationTransaction:
                         f"verification executable not found: {executable_command[0]}"
                     ) from exc
                 finished = dt.datetime.now().astimezone()
+                log_path = _write_verify_log(
+                    self.project_root,
+                    self.transaction_id,
+                    index,
+                    command=command,
+                    resolved_command=executable_command,
+                    started=started,
+                    finished=finished,
+                    exit_code=proc.returncode,
+                    stdout=proc.stdout,
+                    stderr=proc.stderr,
+                )
                 results.append(
                     {
                         "command": list(command),
@@ -1032,6 +1106,7 @@ class IntegrationTransaction:
                         "durationMs": int(
                             (finished - started).total_seconds() * 1000
                         ),
+                        "logPath": log_path,
                     }
                 )
                 if proc.returncode != 0:

package/harness/bundles/java/codebuddy/scripts/harness_preflight.py

@@ -374,12 +374,14 @@ def _resolve_agents_root(skills_root: Path, agents_root: Path | None) -> tuple[P
     return (skills_root / "agents").resolve(), None
 
 
-def _read_host_capabilities(skills_root: Path) -> set[str]:
+def _read_host_capabilities(skills_root: Path) -> tuple[set[str], bool]:
     """Read agent capabilities declared by the host adapter (retro §5.3).
 
     Adapter installs may declare available agent roles in
     `meta/runtime.json` under `agentCapabilities` (list of role names).
-    Returns an empty set if the file or field is absent.
+    Returns ``(capabilities, manifest_present)``. ``manifest_present`` is true
+    only when a readable capability list exists; an unrelated runtime.json
+    must not turn an unknown host into a hard "agent missing" failure.
     """
     # runtime.json lives in the change's meta/ dir, but agent capabilities are
     # project-level. Check the adapter's runtime.json at the project root.
@@ -398,8 +400,8 @@ def _read_host_capabilities(skills_root: Path) -> set[str]:
             continue
         caps = data.get("agentCapabilities")
         if isinstance(caps, list):
-            return {str(c) for c in caps if isinstance(c, str)}
-    return set()
+            return {str(c) for c in caps if isinstance(c, str)}, True
+    return set(), False
 
 
 def cmd_check_agents(
@@ -420,7 +422,7 @@ def cmd_check_agents(
         }
 
     resolved_agents_root, _ = _resolve_agents_root(skills_root, agents_root)
-    host_capabilities = _read_host_capabilities(skills_root)
+    host_capabilities, capability_manifest_present = _read_host_capabilities(skills_root)
     host_callable = agent_name in host_capabilities
 
     # Three independent fields (retro §5.3):
@@ -437,32 +439,37 @@ def cmd_check_agents(
         agent_path = resolved_agents_root / filename
         definition_present = agent_path.is_file()
 
-    # If no local definition and host doesn't declare the role, we can't
-    # determine usability. Distinguish "host says no" from "unknown".
+    # Codex/Cursor bundles intentionally do not install fixed harness-* agent
+    # definitions. Missing host capabilities therefore select the normal
+    # inline path instead of reporting UNKNOWN/"subagent unavailable".
     if not definition_present and not host_callable:
-        # Check if this adapter is known to not support custom agents
         adapter_name = skills_root.parent.name
         if adapter_name in (".agents", ".cursor"):
-            # Codex/Cursor: may support via host manifest. If runtime.json
-            # has agentCapabilities but this role isn't listed, it's a
-            # genuine "not available". If no agentCapabilities field at all,
-            # we can't know — return UNKNOWN.
-            runtime_path = skills_root.parent / "runtime.json"
-            if not runtime_path.is_file():
-                return {
-                    "ok": True,
-                    "action": "check-agents",
-                    "agent": agent_name,
-                    "usable": False,
-                    "definitionPresent": False,
-                    "hostCallable": False,
-                    "toolContractValid": False,
-                    "reasonCode": "UNKNOWN",
-                    "reason": (
-                        "no local agent definition and no host capability manifest; "
-                        "cannot determine agent availability"
-                    ),
-                }
+            reason_code = (
+                "HOST_CAPABILITY_NOT_DECLARED"
+                if capability_manifest_present
+                else "INLINE_BY_ADAPTER"
+            )
+            return {
+                "ok": True,
+                "action": "check-agents",
+                "agent": agent_name,
+                "usable": False,
+                "executionMode": "inline",
+                "fallbackPolicy": "inline-no-retry",
+                "definitionPresent": False,
+                "hostCallable": False,
+                "toolContractValid": False,
+                "capabilityManifestPresent": capability_manifest_present,
+                "reasonCode": reason_code,
+                "reason": (
+                    "host capability manifest does not declare this fixed agent; "
+                    "use the normal inline path"
+                    if capability_manifest_present
+                    else "adapter uses inline execution unless the host explicitly "
+                    "declares a callable agent capability"
+                ),
+            }
         return {
             "ok": False,
             "action": "check-agents",
@@ -470,9 +477,12 @@ def cmd_check_agents(
             "path": str(agent_path) if agent_path else None,
             "agentsRoot": str(resolved_agents_root) if resolved_agents_root else None,
             "usable": False,
+            "executionMode": "unavailable",
+            "fallbackPolicy": "inline-no-retry",
             "definitionPresent": False,
             "hostCallable": False,
             "toolContractValid": False,
+            "capabilityManifestPresent": capability_manifest_present,
             "reasonCode": "AGENT_DEFINITION_NOT_FOUND",
             "reason": f"agent file not found and host does not declare role: {agent_name}",
         }
@@ -488,9 +498,13 @@ def cmd_check_agents(
                 "agent": agent_name,
                 "path": str(agent_path),
                 "usable": False,
+                "executionMode": "unavailable",
+                "fallbackPolicy": "inline-no-retry",
                 "definitionPresent": True,
                 "hostCallable": host_callable,
                 "toolContractValid": False,
+                "capabilityManifestPresent": capability_manifest_present,
+                "reasonCode": "AGENT_DEFINITION_UNREADABLE",
                 "reason": f"cannot read agent file: {exc}",
             }
 
@@ -502,9 +516,13 @@ def cmd_check_agents(
                 "agent": agent_name,
                 "path": str(agent_path),
                 "usable": False,
+                "executionMode": "unavailable",
+                "fallbackPolicy": "inline-no-retry",
                 "definitionPresent": True,
                 "hostCallable": host_callable,
                 "toolContractValid": False,
+                "capabilityManifestPresent": capability_manifest_present,
+                "reasonCode": "AGENT_DEFINITION_INVALID",
                 "reason": f"frontmatter parse failed: {err or 'unknown'}",
             }
 
@@ -525,7 +543,7 @@ def cmd_check_agents(
     name_field = meta.get("name") if meta else None
     tools_field = meta.get("tools") if meta else None
 
-    reason_code = "READY" if usable else "AGENT_DEFINITION_NOT_FOUND"
+    reason_code = "READY" if usable else "TOOL_CONTRACT_INVALID"
     if not definition_present and host_callable:
         reason_code = "DEFINITION_NOT_FOUND_HOST_CAPABLE"
 
@@ -536,9 +554,12 @@ def cmd_check_agents(
         "path": str(agent_path) if agent_path else None,
         "agentsRoot": str(resolved_agents_root) if resolved_agents_root else None,
         "usable": usable,
+        "executionMode": "delegated" if usable else "unavailable",
+        "fallbackPolicy": "inline-no-retry",
         "definitionPresent": definition_present,
         "hostCallable": host_callable,
         "toolContractValid": tool_contract_valid,
+        "capabilityManifestPresent": capability_manifest_present,
         "reasonCode": reason_code,
         "reason": (
             "agent available; "

package/harness/bundles/java/codex/.harness-build.json

@@ -2,5 +2,5 @@
   "schemaVersion": 1,
   "overlay": "java",
   "agent": "codex",
-  "coreHash": "e0c5a35313913ae5"
+  "coreHash": "cfa83d5f8390af7f"
 }