@hunter-harness/workflow-harness 0.2.18 → 0.2.20

package/harness/bundles/general/cursor/scripts/harness_archive.py

@@ -520,6 +520,41 @@ def check_status(
             }
         )
 
+    # --- H-4 formal-layer minimum set ---
+    plans_dir = change_dir / "plans"
+    plan_files = (
+        sorted(plans_dir.glob("*-plan.md")) if plans_dir.is_dir() else []
+    )
+    checks["plan_files"] = [str(p.relative_to(change_dir)) for p in plan_files]
+    if not plan_files:
+        blockers.append(
+            {
+                "code": "missing-plan",
+                "message": "plans/*-plan.md is required before archive",
+            }
+        )
+
+    events_path = change_dir / "events.ndjson"
+    events_present = events_path.is_file() and events_path.stat().st_size > 0
+    checks["events_ndjson"] = events_present
+    if not events_present:
+        blockers.append(
+            {
+                "code": "missing-events",
+                "message": "events.ndjson is required and must be non-empty",
+            }
+        )
+
+    ledger = load_ledger(change_dir)
+    checks["verification_ledger"] = ledger is not None
+    if ledger is None:
+        blockers.append(
+            {
+                "code": "missing-verification-ledger",
+                "message": "evidence/verification-ledger.json is required before archive",
+            }
+        )
+
     # --- commit pushed ---
     code, out, err = git_run(project, "rev-parse", "--is-inside-work-tree")
     if code != 0:
@@ -559,7 +594,8 @@ def check_status(
 
     expected_hash: str | None = None
     hash_source: str | None = None
-    ledger = load_ledger(change_dir)
+    if ledger is None:
+        ledger = load_ledger(change_dir)
     if worktree_requested(change_dir) and ledger:
         merge_hash = ledger.get("mergeFinalHash") or (
             ledger.get("merge") or {}
@@ -625,13 +661,25 @@ def check_status(
     # --- test / review reports ---
     test_reports = find_test_reports(change_dir)
     review_reports = find_review_reports(change_dir)
-    events_path = change_dir / "events.ndjson"
     events = he.load_events(events_path) if events_path.is_file() else []
     review_ran = review_evidence_present(change_dir, events)
 
     checks["test_reports"] = [str(p.relative_to(change_dir)) for p in test_reports]
     checks["review_reports"] = [str(p.relative_to(change_dir)) for p in review_reports]
 
+    # H-4 min blockers are plan/events/ledger only. Missing test/review evidence
+    # remains a warning so archive-before-review stays possible (advisory).
+    if not test_reports and not review_reports and not review_ran:
+        warnings.append(
+            {
+                "code": "missing-test-or-review-report",
+                "message": (
+                    "no test report or review evidence yet; prefer completing "
+                    "test/review before archive (not a hard blocker)"
+                ),
+            }
+        )
+
     if test_reports:
         checks["test_report_status"] = "present"
     else:
@@ -842,15 +890,18 @@ def _ledger_unit_tests(ledger: dict[str, Any] | None) -> dict[str, Any]:
     elif str(unit.get("reused") or "").lower() in {"true", "1"} or "REUSED" in status:
         source = "committed"
 
-    if pass_rate is None and run > 0:
+    if pass_rate is None:
         passed = (
             passed_count
             if passed_count is not None
-            else max(run - failures - errors - skipped, 0)
+            else max(int(run or 0) - int(failures or 0) - int(errors or 0) - int(skipped or 0), 0)
         )
-        pass_rate = f"{passed / run:.0%}"
-    elif pass_rate is None:
-        pass_rate = NOT_AVAILABLE
+        # H-13: passRate denominator excludes skipped.
+        denom = int(passed) + int(failures or 0) + int(errors or 0)
+        if denom > 0:
+            pass_rate = f"{passed / denom:.0%}"
+        else:
+            pass_rate = NOT_AVAILABLE
 
     result = {
         "run": int(run or 0),
@@ -1332,7 +1383,19 @@ def _stage_status_from_sources(
         elif raw in {"SKIP", "SKIPPED"}:
             raw = "USER_SKIPPED"
         status[phase] = raw
-    # Issues in events can downgrade
+    # Issues in events can downgrade. H-14: informational / hygiene / agent-preflight
+    # notes must not downgrade an already-OK phase.end.
+    _informational_markers = (
+        "[archive-hygiene]",
+        "informational",
+        "custom_agents_unsupported",
+        "definition_not_found_host_capable",
+        "知识查询",
+        "knowledge query",
+        "harness-explorer",
+        "harness-evaluator",
+        "委派",
+    )
     for e in he.current_issues(events):
         sev = str(e.get("severity") or "").lower()
         issue_text = " ".join(str(e.get(key) or "") for key in ("message", "note", "code")).lower()
@@ -1341,6 +1404,10 @@ def _stage_status_from_sources(
                 sev = "error"
             elif any(token in issue_text for token in ("warn", "skip", "风险", "警告")):
                 sev = "warn"
+        if sev in {"warn", "warning"} and any(m in issue_text for m in _informational_markers):
+            continue
+        if sev in {"", "info", "note", "informational"}:
+            continue
         phase = str(e.get("phase") or "").lower()
         if phase in status and sev in {"error", "fail", "failed", "critical"}:
             status[phase] = "FAIL"
@@ -1651,6 +1718,51 @@ def _review_summary(
     return base
 
 
+def _resolve_base_commit(
+    ledger: dict[str, Any] | None,
+    change_dir: Path,
+    project: Path,
+    final: str | None,
+) -> str:
+    """Resolve baseCommit: ledger → latest phase-context → merge first parent → merge-base."""
+    if ledger:
+        base = str(ledger.get("baseCommit") or "").strip()
+        if base and base != NOT_AVAILABLE:
+            return base
+
+    ctx_dir = change_dir / "runtime" / "phase-context"
+    if ctx_dir.is_dir():
+        candidates = sorted(
+            (p for p in ctx_dir.glob("*.json") if p.is_file()),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+        for path in candidates:
+            try:
+                payload = read_json(path)
+            except (OSError, json.JSONDecodeError, TypeError):
+                continue
+            if not isinstance(payload, dict):
+                continue
+            base = str(payload.get("baseCommit") or "").strip()
+            if base and base != NOT_AVAILABLE:
+                return base
+
+    final_commit = str(final or "").strip()
+    if final_commit and final_commit != NOT_AVAILABLE:
+        code, parents_line, _ = git_run(
+            project, "rev-list", "--parents", "-n", "1", final_commit
+        )
+        if code == 0 and parents_line:
+            parts = parents_line.split()
+            if len(parts) >= 2:
+                return parts[1]
+        code, merge_base, _ = git_run(project, "merge-base", final_commit, "HEAD")
+        if code == 0 and merge_base and merge_base != final_commit:
+            return merge_base
+    return ""
+
+
 def _final_commit_from_sources(
     ledger: dict[str, Any] | None,
     events: list[dict[str, Any]],
@@ -1864,12 +1976,21 @@ def collect_summary_data(
         data["finalCommit"] = final_commit or (NOT_AVAILABLE if for_replay else "")
 
     if not data.get("baseCommit") or str(data.get("baseCommit")).startswith("<"):
-        if ledger and ledger.get("baseCommit"):
-            data["baseCommit"] = ledger["baseCommit"]
-        elif existing and existing.get("baseCommit"):
+        if for_replay and existing and existing.get("baseCommit"):
             data["baseCommit"] = existing["baseCommit"]
         else:
-            data["baseCommit"] = NOT_AVAILABLE if for_replay else ""
+            resolved_base = _resolve_base_commit(
+                ledger,
+                change_dir,
+                project,
+                str(data.get("finalCommit") or "") or None,
+            )
+            if resolved_base:
+                data["baseCommit"] = resolved_base
+            elif existing and existing.get("baseCommit"):
+                data["baseCommit"] = existing["baseCommit"]
+            else:
+                data["baseCommit"] = NOT_AVAILABLE if for_replay else ""
 
     if not data.get("finalCommitBranch") or str(data.get("finalCommitBranch")).startswith("<"):
         code, branch, _ = git_run(project, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
@@ -2002,6 +2123,16 @@ def collect_summary_data(
             }
             data["changedFiles"] = []
 
+    # H-11: surface identity + diff facts for adequacy (top-level + gitFacts).
+    diff_for_facts = data.get("diffStat") if isinstance(data.get("diffStat"), dict) else {}
+    data["gitFacts"] = {
+        "baseCommit": data.get("baseCommit") or "",
+        "finalCommit": data.get("finalCommit") 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),
+    }
+
     data.setdefault(
         "ownershipDiff",
         {
@@ -2837,18 +2968,52 @@ def validate_report_adequacy(summary: dict[str, Any]) -> dict[str, Any]:
     """
     issues: list[dict[str, str]] = []
 
+    # H-12: prefer top-level baseCommit + diffStat; gitFacts is a mirror.
+    base = str(summary.get("baseCommit") or "").strip()
+    final = str(summary.get("finalCommit") or "").strip()
+    merge_final = str(summary.get("mergeFinalHash") or "").strip()
+    diff_stat = summary.get("diffStat") if isinstance(summary.get("diffStat"), dict) else {}
+    files_changed = int(diff_stat.get("filesChanged") or 0)
+
     git_facts = summary.get("gitFacts") or {}
     if isinstance(git_facts, dict):
-        base = str(git_facts.get("baseCommit") or "").strip()
-        final = str(git_facts.get("finalCommit") or "").strip()
-        files_changed = int(git_facts.get("filesChanged") or 0)
-        # base != final but diff=0 → factually incomplete.
-        if base and final and base != final and files_changed == 0:
-            issues.append({
-                "code": "DIFF_ZERO_WITH_NONEMPTY_COMMIT",
-                "severity": "error",
-                "message": f"final commit {final} differs from base {base} but filesChanged=0",
-            })
+        if not base or base == NOT_AVAILABLE:
+            base = str(git_facts.get("baseCommit") or "").strip() or base
+        if not final or final == NOT_AVAILABLE:
+            final = str(git_facts.get("finalCommit") or "").strip() or final
+        if "filesChanged" in git_facts and files_changed == 0:
+            try:
+                files_changed = int(git_facts.get("filesChanged") or 0)
+            except (TypeError, ValueError):
+                files_changed = 0
+
+    base_missing = not base or base == NOT_AVAILABLE
+    final_present = bool(
+        (final and final != NOT_AVAILABLE) or (merge_final and merge_final != NOT_AVAILABLE)
+    )
+    if final_present and base_missing:
+        issues.append({
+            "code": "IDENTITY_BASE_MISSING",
+            "severity": "error",
+            "message": (
+                "final/merge identity present but baseCommit is empty; "
+                "refuse CONDITIONAL_OK+ without a resolved base"
+            ),
+        })
+
+    if (
+        base
+        and final
+        and base != NOT_AVAILABLE
+        and final != NOT_AVAILABLE
+        and base != final
+        and files_changed == 0
+    ):
+        issues.append({
+            "code": "DIFF_ZERO_WITH_NONEMPTY_COMMIT",
+            "severity": "error",
+            "message": f"final commit {final} differs from base {base} but filesChanged=0",
+        })
 
     # Typed metrics missing despite test report artifacts present.
     verification = summary.get("verification") or {}
@@ -2886,11 +3051,11 @@ def validate_report_adequacy(summary: dict[str, Any]) -> dict[str, Any]:
 
 
 def artifact_preflight(change_dir: Path) -> dict[str, Any]:
-    """Classify artifact events before destructive finalize (retro §5.31).
+    """Classify artifact events before destructive finalize (retro §5.31 / H-8).
 
-    Returns per-artifact classification: informational (no path, OK),
-    canonicalizable (same-change repo-relative path, auto-normalize), or
-    blocking (cross-change/absolute/escaping path, fail closed).
+    Returns per-artifact classification: blocking (missing / escaping /
+    cross-change path), canonicalizable (same-change repo-relative path),
+    or file-backed (change-relative path). Pathless legacy rows fail closed.
     """
     change_dir = change_dir.resolve()
     events_p = change_dir / "events.ndjson"
@@ -2910,12 +3075,16 @@ def artifact_preflight(change_dir: Path) -> dict[str, Any]:
         kind = str(event.get("kind") or "").strip()
         event_id = str(event.get("id") or "")
         if not path:
-            items.append({
+            item = {
                 "eventId": event_id,
-                "category": "informational",
-                "kind": kind or "informational",
+                "category": "blocking",
+                "path": "",
+                "kind": kind or "",
+                "reason": "artifact path missing",
                 "note": str(event.get("note") or "")[:80],
-            })
+            }
+            items.append(item)
+            blocking.append(item)
             continue
         # Check for escaping/cross-change paths.
         parts = path.replace("\\", "/").split("/")

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

@@ -679,29 +679,16 @@ def validate_append_event(args: argparse.Namespace) -> tuple[str, str] | None:
                 "CORRECTION_VALUE_INVALID_JSON",
                 f"CORRECTION_VALUE_INVALID_JSON: {exc}",
             )
-    # Retro §5.31: artifact events must distinguish file-backed from
-    # informational. file-backed requires a change-relative path; informational
-    # (preview/summary) must not masquerade as a file artifact. Legacy kind
-    # values (ledger, report, etc.) are treated as file-backed aliases.
+    # Retro 2026-07-21 H-8: artifact events always require a non-empty path.
+    # Knowledge/exploration notes must use issue/decision, not pathless artifacts.
     if event_type == "artifact":
-        kind = str(getattr(args, "kind", "") or "").strip()
         path = str(getattr(args, "path", "") or "").strip()
-        is_informational = kind == "informational"
-        if kind == "file-backed" and not path:
-            return (
-                "ARTIFACT_PATH_REQUIRED",
-                "ARTIFACT_PATH_REQUIRED: file-backed artifact requires --path",
-            )
-        # If kind is explicitly informational, path is optional. If kind is
-        # absent and path is absent, reject (can't infer file-backed without path).
-        if not kind and not path:
+        if not path:
             return (
                 "ARTIFACT_PATH_REQUIRED",
-                "ARTIFACT_PATH_REQUIRED: artifact without --kind or --path is ambiguous; "
-                "use --kind informational for previews or --path for file artifacts",
+                "ARTIFACT_PATH_REQUIRED: artifact requires --path "
+                "(use issue/decision for informational notes)",
             )
-        # If no kind is provided, infer from path presence: a path implies
-        # file-backed, absence implies informational (legacy compatibility).
     return None
 
 

package/harness/bundles/general/cursor/scripts/harness_integration.py

@@ -109,6 +109,10 @@ class CleanupResidualError(IntegrationError):
         )
 
 
+class AbandonRefusedError(IntegrationError):
+    code = "ABANDON_REFUSED"
+
+
 class JournalConflictError(IntegrationError):
     code = "JOURNAL_CONFLICT"
 
@@ -740,6 +744,8 @@ class IntegrationTransaction:
                 str(intg_root),
                 self.temp_branch,
             )
+            # H-5: LF-stable hashing in the integration worktree.
+            self.runner.run(intg_root, "config", "core.autocrlf", "false")
 
         return self._run_step("prepare", action)
 
@@ -1195,6 +1201,148 @@ class IntegrationTransaction:
         harness_change.integration_lock_release(self.project_root, run_id=self.run_id)
         return journal
 
+    # ------------------------------------------------------------ abandon
+
+    def _remote_contains_merge(self, journal: dict[str, Any]) -> bool:
+        merge_commit = str(journal.get("mergeCommit") or "")
+        if not merge_commit:
+            return False
+        remote_line = self.runner.text(
+            self.project_root, "ls-remote", "origin", self.target_branch
+        )
+        observed_remote = (
+            remote_line.split()[0] if remote_line and remote_line.split() else ""
+        )
+        return bool(observed_remote and observed_remote == merge_commit)
+
+    def _force_remove_integration_root(
+        self, journal: dict[str, Any], intg_root: Path
+    ) -> dict[str, Any]:
+        """Best-effort remove of the integration worktree for abandon only."""
+        allowed = Path(str(journal.get("allowedCleanupRoot") or "")).resolve()
+        resolved = harness_paths.assert_path_within(intg_root, self.temp_root)
+        if not allowed or resolved != allowed:
+            raise CleanupRefusedError(
+                f"refusing to abandon non-transaction path: {resolved}"
+            )
+        self.runner.run(
+            self.project_root,
+            "worktree",
+            "remove",
+            "--force",
+            str(resolved),
+            check=False,
+        )
+        residual: list[str] = []
+        if resolved.exists():
+            for name in HEAVY_WORKTREE_ROOTS:
+                heavy = resolved / name
+                if heavy.exists():
+                    harness_paths.assert_path_within(heavy, resolved)
+                    try:
+                        if heavy.is_dir() and not heavy.is_symlink():
+                            shutil.rmtree(heavy)
+                        else:
+                            heavy.unlink()
+                    except OSError:
+                        residual.append(name)
+            if resolved.exists():
+                try:
+                    shutil.rmtree(resolved)
+                except OSError:
+                    residual.append(str(resolved))
+        listed = self.runner.text(self.project_root, "worktree", "list", "--porcelain")
+        still_registered = str(resolved) in {
+            str(Path(line.removeprefix("worktree ")).resolve())
+            for line in (listed or "").splitlines()
+            if line.startswith("worktree ")
+        }
+        ok = not still_registered and not residual and not resolved.exists()
+        return {
+            "ok": ok,
+            "code": "CLEANUP_COMPLETE" if ok else "CLEANUP_RESIDUAL",
+            "target": str(resolved),
+            "worktreeRegistered": still_registered,
+            "diskPathPresent": resolved.exists(),
+            "residualPaths": residual,
+        }
+
+    def abandon(self) -> dict[str, Any]:
+        """Official recovery for a failed integration transaction (H-6).
+
+        Allowed only when push is not DONE and the remote does not already
+        contain ``mergeCommit``. Removes the integration worktree, temp branch,
+        protection refs, and integration lock. Never deletes the feature
+        worktree or feature branch.
+        """
+        try:
+            journal = self._load()
+        except FileNotFoundError as exc:
+            raise AbandonRefusedError(
+                f"no journal for transaction {self.transaction_id}"
+            ) from exc
+
+        push_status = str(self._step(journal, "push").get("status") or "")
+        push_intent = journal.get("pushIntent") or {}
+        push_confirmed = (
+            push_status == "DONE"
+            or (
+                isinstance(push_intent, dict)
+                and push_intent.get("status") == "REMOTE_CONFIRMED"
+            )
+            or bool(journal.get("pushedHead"))
+            or bool(journal.get("mergeFinalHash"))
+        )
+        remote_has_merge = self._remote_contains_merge(journal)
+        if push_confirmed or remote_has_merge:
+            raise AbandonRefusedError(
+                "refuse abandon: push succeeded or remote already contains "
+                "the merge commit; use cleanup instead"
+            )
+
+        intg_root = Path(str(journal.get("integrationRoot") or ""))
+        cleanup_result: dict[str, Any] = {
+            "ok": True,
+            "code": "ALREADY_ABSENT",
+            "target": str(intg_root) if intg_root else "",
+            "worktreeRegistered": False,
+            "diskPathPresent": False,
+            "residualPaths": [],
+        }
+        prepare_done = self._step(journal, "prepare").get("status") == "DONE"
+        if prepare_done and str(journal.get("integrationRoot") or "").strip():
+            try:
+                cleanup_result = self.cleanup_target(intg_root)
+            except CleanupRefusedError:
+                cleanup_result = self._force_remove_integration_root(journal, intg_root)
+
+        self.runner.run(
+            self.project_root, "branch", "-D", self.temp_branch, check=False
+        )
+        refs = journal.get("protectionRefs") or {}
+        if isinstance(refs, dict):
+            for ref in (refs.get("base"), refs.get("head")):
+                if ref:
+                    self.runner.run(
+                        self.project_root, "update-ref", "-d", str(ref), check=False
+                    )
+
+        harness_change.integration_lock_release(self.project_root, run_id=self.run_id)
+
+        journal = self._load()
+        journal["abandonedAt"] = now_iso()
+        journal["abandonResult"] = cleanup_result
+        self._save(journal)
+
+        return {
+            "ok": True,
+            "code": "ABANDON_COMPLETE",
+            "transactionId": self.transaction_id,
+            "cleanup": cleanup_result,
+            "featureBranchRetained": True,
+            "featureWorktreeRetained": True,
+        }
+
     # ------------------------------------------------------------ recover
 
     def recover(
@@ -1282,6 +1430,10 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
     return _emit(_txn_from_args(args).cleanup())
 
 
+def cmd_abandon(args: argparse.Namespace) -> int:
+    return _emit(_txn_from_args(args).abandon())
+
+
 def cmd_recover(args: argparse.Namespace) -> int:
     return _emit(_txn_from_args(args).recover())
 
@@ -1333,6 +1485,7 @@ def build_parser() -> argparse.ArgumentParser:
     add("merge", cmd_merge)
     add("push", cmd_push)
     add("cleanup", cmd_cleanup)
+    add("abandon", cmd_abandon)
     add("recover", cmd_recover)
     add("status", cmd_status)
 

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

@@ -28,6 +28,7 @@ if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
 import harness_paths  # noqa: E402
+import harness_profile  # noqa: E402
 
 
 if hasattr(sys.stdout, "reconfigure"):
@@ -131,8 +132,19 @@ def emit_compact_or_verbose(
     emit_json(out, as_json=as_json)
 
 
-def emit_error(message: str, *, as_json: bool, code: int = 1) -> int:
-    payload = {"ok": False, "error": message}
+def emit_error(
+    message: str,
+    *,
+    as_json: bool,
+    code: int = 1,
+    error_code: str | None = None,
+    extra: dict[str, Any] | None = None,
+) -> int:
+    payload: dict[str, Any] = {"ok": False, "error": message}
+    if error_code:
+        payload["code"] = error_code
+    if extra:
+        payload.update(extra)
     if as_json:
         sys.stderr.write(json.dumps(payload, ensure_ascii=False) + "\n")
     else:
@@ -523,18 +535,30 @@ def expand_profile_input_files(
 ) -> tuple[list[str], str | None]:
     """Expand verificationInputs[profile_input] globs from build-profile.json.
 
-    Globs are relative to project; only files inside project are kept
-    (deduped, path-sorted). Returns (files, error); error is None on success.
+    Profile is loaded via ``harness_profile.load_profile`` (C7: common_root then
+    execution overlay) so linked worktrees without a local build-profile still
+    reuse the main checkout profile. Globs remain relative to the execution
+    ``project`` root (not common_root) so inputsHash tracks the tree under test.
+
+    Returns (files, error); error is None on success.
     profile 缺失 / key 缺失 / glob 无匹配 / 结果为空 → 返回 ([], "<reason>")，
     调用方据此返回 insufficient-evidence，执行全量测试但不允许缓存复用。
     """
-    profile_path = project / ".harness" / "config" / "build-profile.json"
-    if not profile_path.is_file():
+    profile = harness_profile.load_profile(Path(project))
+    if profile is None:
+        # load_profile swallows JSON errors; restore actionable unreadable diag
+        # when a profile file exists but cannot be parsed (review YELLOW-1).
+        project_root = Path(project).resolve()
+        common = harness_paths.common_root(project_root)
+        for root in (common, project_root):
+            candidate = root / ".harness" / "config" / "build-profile.json"
+            if not candidate.is_file():
+                continue
+            try:
+                json.loads(candidate.read_text(encoding="utf-8-sig"))
+            except (OSError, json.JSONDecodeError) as exc:
+                return [], f"build-profile.json unreadable: {exc}"
         return [], "build-profile.json missing; run harness_preflight.py detect"
-    try:
-        profile = json.loads(profile_path.read_text(encoding="utf-8-sig"))
-    except (OSError, json.JSONDecodeError) as exc:
-        return [], f"build-profile.json unreadable: {exc}"
     if not isinstance(profile, dict):
         return [], "build-profile.json is not an object"
     inputs = profile.get("verificationInputs")
@@ -544,7 +568,7 @@ def expand_profile_input_files(
     if not isinstance(patterns, list) or not patterns:
         return [], f"verificationInputs.{profile_input} is empty or invalid"
 
-    base = project.resolve()
+    base = Path(project).resolve()
     seen: set[str] = set()
     for pat in patterns:
         if not isinstance(pat, str) or not pat.strip():
@@ -1520,6 +1544,8 @@ def cmd_record(args: argparse.Namespace) -> int:
                 return emit_error(
                     "ledger identity incomplete: " + ", ".join(missing),
                     as_json=as_json,
+                    error_code="LEDGER_IDENTITY_INVALID",
+                    extra={"missing": missing},
                 )
         write_ledger(out_path, ledger)
     except (OSError, ValueError, FileNotFoundError, json.JSONDecodeError) as exc: