@hunter-harness/workflow-harness 0.2.15 → 0.2.17

package/harness/bundles/java/codex/protocols/submit-protocol.md

@@ -1,5 +1,5 @@
 ---
-description: harness-submit 的确定性提交协议。用于避免 AskUserQuestion 参数错误、中文 commit message 失败、Co-Authored-By 违规和先 commit 后 amend。
+description: harness-submit 的确定性提交协议。用于避免 blocking user confirmation 参数错误、中文 commit message 失败、Co-Authored-By 违规和先 commit 后 amend。
 ---
 
 # Submit Protocol

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

@@ -26,6 +26,10 @@ if hasattr(sys.stderr, "reconfigure"):
     sys.stderr.reconfigure(encoding="utf-8")
 
 INCLUDE_RE = re.compile(r"<!--\s*@include\s+shared/([^\s]+)\s*-->")
+# retro §5.17: wiki links [[shared/xxx.md|alias]] reference shared fragments
+# that are inlined by expand_includes. After expansion, replace the wiki link
+# with the alias text (the shared content is already in the document).
+WIKI_LINK_RE = re.compile(r"\[\[shared/([^\]|]+)\|([^\]]*)\]\]")
 # §7.5: overlay anchors support both new section-id and legacy section:"title".
 OVERRIDE_RE = re.compile(r'<!--\s*@override\s+(?:section-id:"([^"]+)"|section:"([^"]+)")\s*-->')
 APPEND_RE = re.compile(r'<!--\s*@append-after\s+(?:section-id:"([^"]+)"|section:"([^"]+)")\s*-->')
@@ -148,6 +152,9 @@ def expand_includes(text: str, shared_dir: Path) -> str:
         return body
 
     expanded = INCLUDE_RE.sub(repl, text)
+    # §5.17: replace [[shared/xxx.md|alias]] wiki links with the alias text,
+    # since the shared content has been inlined by @include expansion above.
+    expanded = WIKI_LINK_RE.sub(lambda m: m.group(2), expanded)
     lines = [ln for ln in expanded.splitlines() if not FRAGMENT_HINT_RE.match(ln)]
     return "\n".join(lines) + ("\n" if text.endswith("\n") else "")
 

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

@@ -1201,6 +1201,70 @@ def _phase_event_exists(change_dir: Path, phase: str, type_: str, run_id: str) -
     )
 
 
+def _validate_scenario_coverage(change_dir: Path) -> dict[str, Any]:
+    """C9: validate all P0 scenarios have a ledger entry with scenarioIds covering them.
+
+    Reads meta/scenario-manifest.json and evidence/verification-ledger.json.
+    Returns ok=True when manifest missing (backward compat) or all P0 scenarios covered.
+    """
+    manifest_path = change_dir / "meta" / "scenario-manifest.json"
+    if not manifest_path.is_file():
+        return {"ok": True, "code": "MANIFEST_MISSING", "skipped": True}
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError) as exc:
+        return {
+            "ok": False,
+            "code": "SCENARIO_MANIFEST_INVALID",
+            "message": f"scenario-manifest.json unreadable: {exc}",
+        }
+    scenarios = manifest.get("scenarios") or []
+    p0_ids = {
+        str(s.get("id"))
+        for s in scenarios
+        if isinstance(s, dict)
+        and str(s.get("priority", "")).upper() == "P0"
+        and s.get("requiredEvidenceKind") == "ledger"
+    }
+    if not p0_ids:
+        return {"ok": True, "code": "NO_P0_SCENARIOS"}
+
+    ledger_path = change_dir / "evidence" / "verification-ledger.json"
+    if not ledger_path.is_file():
+        return {
+            "ok": False,
+            "code": "SCENARIO_COVERAGE_FAILED",
+            "message": "ledger missing; cannot verify P0 scenario coverage",
+            "missing": sorted(p0_ids),
+        }
+    try:
+        ledger = json.loads(ledger_path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError) as exc:
+        return {
+            "ok": False,
+            "code": "SCENARIO_COVERAGE_FAILED",
+            "message": f"ledger unreadable: {exc}",
+            "missing": sorted(p0_ids),
+        }
+    covered: set[str] = set()
+    validations = ledger.get("validations") or {}
+    if isinstance(validations, dict):
+        for entry in validations.values():
+            if isinstance(entry, dict):
+                ids = entry.get("scenarioIds")
+                if isinstance(ids, list):
+                    covered.update(str(i) for i in ids)
+    missing = sorted(p0_ids - covered)
+    if missing:
+        return {
+            "ok": False,
+            "code": "SCENARIO_COVERAGE_FAILED",
+            "message": f"P0 scenarios without ledger entry: {', '.join(missing)}",
+            "missing": missing,
+        }
+    return {"ok": True, "code": "SCENARIO_COVERAGE_OK", "covered": sorted(covered & p0_ids)}
+
+
 def cmd_begin(args: argparse.Namespace) -> int:
     as_json = bool(args.json)
     project = hc.resolve_main_project_root()
@@ -1470,6 +1534,17 @@ def cmd_close(args: argparse.Namespace) -> int:
             extra={k: v for k, v in ledger_result.items() if k not in {"ok", "message", "code"}},
         )
 
+    # C9: scenario coverage check — all P0 scenarios must have a ledger entry.
+    if args.phase in {"run", "test"}:
+        coverage = _validate_scenario_coverage(change_dir)
+        if not coverage.get("ok"):
+            return emit_error(
+                str(coverage.get("code", "SCENARIO_COVERAGE_FAILED")),
+                str(coverage.get("message", "scenario coverage validation failed")),
+                as_json=as_json,
+                extra={k: v for k, v in coverage.items() if k not in {"ok", "message", "code"}},
+            )
+
     close_status = args.status
     close_code = "PHASE_CLOSED"
     if ledger_result.get("code") == "LEDGER_OK_DEGRADED":

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

@@ -1049,10 +1049,11 @@ class IntegrationTransaction:
                     heavy_removed.append(name)
                 except OSError as exc:
                     heavy_failures.append({"path": name, "error": str(exc)})
-        self.runner.run(
+        remove_result = self.runner.run(
             self.project_root, "worktree", "remove", "--force", str(resolved),
             check=False,
         )
+        remove_returncode = getattr(remove_result, "returncode", 0)
         listed = self.runner.text(self.project_root, "worktree", "list", "--porcelain")
         registered_after = {
             str(Path(line.removeprefix("worktree ")).resolve())
@@ -1061,7 +1062,8 @@ class IntegrationTransaction:
         }
         still_registered = str(resolved) in registered_after
         residual_paths: list[str] = []
-        if resolved.exists():
+        disk_path_present = resolved.exists()
+        if disk_path_present:
             if resolved.is_file():
                 residual_paths.append(resolved.name)
             else:
@@ -1075,6 +1077,27 @@ class IntegrationTransaction:
                             break
                     if len(residual_paths) >= 200:
                         break
+        # §5.30: Windows half-success — git worktree remove returned non-zero
+        # but registration is already deleted and disk path remains. Return a
+        # structured status distinct from generic CLEANUP_RESIDUAL so callers
+        # can apply the allowlisted residual cleaner.
+        if (
+            remove_returncode != 0
+            and not still_registered
+            and disk_path_present
+            and residual_paths
+            and not heavy_failures
+        ):
+            return {
+                "ok": False,
+                "code": "REGISTRATION_REMOVED_RESIDUAL_PRESENT",
+                "target": str(resolved),
+                "heavyRootsRemoved": heavy_removed,
+                "heavyRootFailures": heavy_failures,
+                "worktreeRegistered": False,
+                "diskPathPresent": True,
+                "residualPaths": residual_paths,
+            }
         ok = not heavy_failures and not still_registered and not residual_paths
         return {
             "ok": ok,
@@ -1083,6 +1106,7 @@ class IntegrationTransaction:
             "heavyRootsRemoved": heavy_removed,
             "heavyRootFailures": heavy_failures,
             "worktreeRegistered": still_registered,
+            "diskPathPresent": disk_path_present,
             "residualPaths": residual_paths,
         }
 
@@ -1266,6 +1290,31 @@ def cmd_status(args: argparse.Namespace) -> int:
     return _emit(_txn_from_args(args).status())
 
 
+def cmd_journal(args: argparse.Namespace) -> int:
+    """C5: journal 子命令 — 默认 compact (transactionId/currentStep/status)，--verbose 全量。"""
+    txn = _txn_from_args(args)
+    full = txn.status()
+    if getattr(args, "verbose", False):
+        return _emit(full)
+    # Derive currentStep: first non-DONE step, or last step name if all DONE.
+    current_step = None
+    for step in full.get("steps", []):
+        if step.get("status") != "DONE":
+            current_step = step.get("name")
+            break
+    if current_step is None and full.get("steps"):
+        current_step = full["steps"][-1].get("name")
+    overall_status = "DONE" if all(
+        step.get("status") == "DONE" for step in full.get("steps", [])
+    ) else "IN_PROGRESS"
+    compact = {
+        "transactionId": full.get("transactionId"),
+        "currentStep": current_step,
+        "status": overall_status,
+    }
+    return _emit(compact)
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="harness_integration.py")
     sub = parser.add_subparsers(dest="command_name", required=True)
@@ -1287,6 +1336,19 @@ def build_parser() -> argparse.ArgumentParser:
     add("recover", cmd_recover)
     add("status", cmd_status)
 
+    p_journal = sub.add_parser("journal")
+    p_journal.add_argument("--change", required=True)
+    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(
+        "--verbose",
+        action="store_true",
+        help="emit full journal payload (default: compact transactionId/currentStep/status)",
+    )
+    p_journal.set_defaults(func=cmd_journal)
+
     p_verify = sub.add_parser("verify")
     p_verify.add_argument("--change", required=True)
     p_verify.add_argument("--run-id", required=True)

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

@@ -100,6 +100,37 @@ def emit_json(payload: dict[str, Any], *, as_json: bool) -> None:
             sys.stdout.write(("ok" if ok else "error") + "\n")
 
 
+def _compact_record_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """C5: record compact — ok/action/verification/status only."""
+    return {
+        "ok": payload.get("ok", True),
+        "action": payload.get("action"),
+        "verification": payload.get("verification"),
+        "status": payload.get("status"),
+    }
+
+
+def _compact_can_reuse_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    """C5: can-reuse compact — ok/reuse/code only."""
+    return {
+        "ok": payload.get("ok", True),
+        "reuse": payload.get("reuse"),
+        "code": payload.get("code"),
+    }
+
+
+def emit_compact_or_verbose(
+    payload: dict[str, Any],
+    *,
+    as_json: bool,
+    verbose: bool,
+    compact_fn,
+) -> None:
+    """Emit compact payload by default; full payload when --verbose."""
+    out = payload if verbose else compact_fn(payload)
+    emit_json(out, as_json=as_json)
+
+
 def emit_error(message: str, *, as_json: bool, code: int = 1) -> int:
     payload = {"ok": False, "error": message}
     if as_json:
@@ -1227,6 +1258,7 @@ def cmd_hash(args: argparse.Namespace) -> int:
 
 def cmd_can_reuse(args: argparse.Namespace) -> int:
     as_json = bool(args.json)
+    verbose = bool(getattr(args, "verbose", False))
     verification = args.verification
     if verification not in VERIFICATIONS:
         return emit_error(
@@ -1253,7 +1285,10 @@ def cmd_can_reuse(args: argparse.Namespace) -> int:
                 "verification": verification,
                 "detail": err,
             }
-            emit_json(payload, as_json=as_json)
+            emit_compact_or_verbose(
+                payload, as_json=as_json, verbose=verbose,
+                compact_fn=_compact_can_reuse_payload,
+            )
             return 0
         files = resolve_input_files(resolved_files, project_root)
     if not files:
@@ -1275,12 +1310,16 @@ def cmd_can_reuse(args: argparse.Namespace) -> int:
     except (OSError, ValueError, json.JSONDecodeError) as exc:
         return emit_error(f"can-reuse failed: {exc}", as_json=as_json)
 
-    emit_json(payload, as_json=as_json)
+    emit_compact_or_verbose(
+        payload, as_json=as_json, verbose=verbose,
+        compact_fn=_compact_can_reuse_payload,
+    )
     return 0
 
 
 def cmd_record(args: argparse.Namespace) -> int:
     as_json = bool(args.json)
+    verbose = bool(getattr(args, "verbose", False))
     change_dir = resolve_path(args.change_dir)
     verification = args.verification
     if verification not in VERIFICATIONS:
@@ -1421,6 +1460,16 @@ def cmd_record(args: argparse.Namespace) -> int:
             if _nonempty_str(getattr(args, "tests_reused_from", None)):
                 entry["testsReusedFrom"] = str(args.tests_reused_from).strip()
 
+        # C9: bind scenario IDs from --scenario-ids to this ledger entry.
+        scenario_ids_raw = getattr(args, "scenario_ids", None)
+        if _nonempty_str(scenario_ids_raw):
+            ids = [s.strip() for s in str(scenario_ids_raw).split(",") if s.strip()]
+            if ids:
+                entry["scenarioIds"] = ids
+        elif "scenarioIds" in entry:
+            # Fresh record without scenario-ids must not keep stale ids from prev.
+            entry.pop("scenarioIds", None)
+
         ledger["validations"][verification] = entry
         if "changeName" not in ledger:
             ledger["changeName"] = change_dir.name
@@ -1487,7 +1536,10 @@ def cmd_record(args: argparse.Namespace) -> int:
         "diffHash": ledger.get("diffHash"),
         "resolvedProjectRoot": str(project_root) if project_root else None,
     }
-    emit_json(payload, as_json=as_json)
+    emit_compact_or_verbose(
+        payload, as_json=as_json, verbose=verbose,
+        compact_fn=_compact_record_payload,
+    )
     return 0
 
 
@@ -1589,6 +1641,11 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="optional environment hash to compare against ledger entry (UT-017)",
     )
+    p_reuse.add_argument(
+        "--verbose",
+        action="store_true",
+        help="emit full payload (default: compact ok/reuse/code)",
+    )
     p_reuse.set_defaults(func=cmd_can_reuse)
 
     p_record = sub.add_parser("record", parents=[shared_json], help="write validation result into ledger")
@@ -1669,6 +1726,16 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="ledger v3: scope reason (required when --applicability NOT_APPLICABLE)",
     )
+    p_record.add_argument(
+        "--scenario-ids",
+        default=None,
+        help="comma-separated scenario IDs from scenario-manifest.json to bind to this entry",
+    )
+    p_record.add_argument(
+        "--verbose",
+        action="store_true",
+        help="emit full payload (default: compact ok/action/verification/status)",
+    )
     p_record.set_defaults(func=cmd_record)
 
     p_diff = sub.add_parser(

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

@@ -83,6 +83,23 @@ def _git_common_dir(cwd: Path) -> Path | None:
     return common
 
 
+def common_root(project_root: Path) -> Path:
+    """Resolve the shared "common" root for a project.
+
+    For a linked worktree, ``git rev-parse --git-common-dir`` points at the
+    main repository's ``.git`` directory; its parent is the main project root.
+    For the main worktree, the common dir is ``<root>/.git`` so the parent is
+    the project root itself. Falls back to the resolved input when not in a
+    git repo (e.g. exploratory scratch dirs).
+    """
+    cwd = Path(project_root).resolve()
+    common = _git_common_dir(cwd)
+    if common is None:
+        return cwd
+    # common dir is <root>/.git — its parent is the main project root.
+    return common.parent.resolve()
+
+
 def _root_commit(cwd: Path) -> str | None:
     raw = _git_text(cwd, "rev-list", "--max-parents=0", "HEAD")
     if not raw: