@elvis1513/auto-coding-skill 2.0.6 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -6,6 +6,7 @@ from __future__ import annotations
6
6
 
7
7
  import argparse
8
8
  import base64
9
+ import hashlib
9
10
  import datetime as _dt
10
11
  import fnmatch
11
12
  import json
@@ -19,6 +20,11 @@ import urllib.request
19
20
  from pathlib import Path
20
21
  from typing import Optional, List
21
22
 
23
+ try:
24
+ import yaml # type: ignore
25
+ except Exception:
26
+ yaml = None
27
+
22
28
  from core import APError, ensure_git_repo, copy_tree, run, load_yaml, find_config, run_shell, http_get_status
23
29
 
24
30
 
@@ -51,14 +57,92 @@ def _join_url(base: str, path: str) -> str:
51
57
  return base + path
52
58
 
53
59
 
60
+ def _now_iso() -> str:
61
+ return _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds")
62
+
63
+
64
+ def _repo_rel(repo: Path, path: Path) -> str:
65
+ try:
66
+ return str(path.resolve().relative_to(repo.resolve())).replace("\\", "/")
67
+ except Exception:
68
+ return str(path).replace("\\", "/")
69
+
70
+
71
+ def _append_jsonl(path: Path, payload: dict) -> None:
72
+ path.parent.mkdir(parents=True, exist_ok=True)
73
+ with path.open("a", encoding="utf-8") as handle:
74
+ handle.write(json.dumps(payload, ensure_ascii=False, sort_keys=True))
75
+ handle.write("\n")
76
+
77
+
78
+ def _evidence_log_path(repo: Path, cfg: dict) -> Path:
79
+ docs_cfg = cfg.get("docs") or {}
80
+ rel = _text(docs_cfg.get("evidence_log")) or "docs/tasks/evidence.jsonl"
81
+ return Path(repo, rel)
82
+
83
+
84
+ def _gate_profile_path(repo: Path, cfg: dict) -> Path:
85
+ gate_cfg = _gate_cfg(cfg)
86
+ rel = _text(gate_cfg.get("profile_log")) or ".local/auto-coding-skill/gate-profile.jsonl"
87
+ return Path(repo, rel)
88
+
89
+
90
+ def _record_evidence(repo: Path, cfg: dict, event: str, status: str, payload: Optional[dict] = None) -> None:
91
+ record = {
92
+ "timestamp": _now_iso(),
93
+ "event": event,
94
+ "status": status,
95
+ "repo": str(repo),
96
+ }
97
+ if payload:
98
+ record.update(payload)
99
+ try:
100
+ _append_jsonl(_evidence_log_path(repo, cfg), record)
101
+ except Exception as exc:
102
+ print(f"[evidence] WARN: failed to write evidence log: {exc}", file=sys.stderr)
103
+
104
+
105
+ def _record_gate_profile(
106
+ repo: Path,
107
+ cfg: dict,
108
+ name: str,
109
+ status: str,
110
+ duration_s: float,
111
+ scope: str = "",
112
+ detail: str = "",
113
+ ) -> None:
114
+ record = {
115
+ "timestamp": _now_iso(),
116
+ "name": name,
117
+ "status": status,
118
+ "duration_s": round(duration_s, 3),
119
+ "scope": scope,
120
+ "detail": detail,
121
+ }
122
+ try:
123
+ _append_jsonl(_gate_profile_path(repo, cfg), record)
124
+ except Exception as exc:
125
+ print(f"[gate-profile] WARN: failed to write profile log: {exc}", file=sys.stderr)
126
+
127
+
54
128
  def _run_configured_command(repo: Path, cfg: dict, name: str) -> bool:
55
129
  commands = (cfg.get("commands") or {})
56
130
  command = str(commands.get(name) or "").strip()
57
131
  if not command:
58
132
  return False
59
133
  print(f"[run] {name}: {command}")
60
- run_shell(command, cwd=repo)
61
- print(f"[run] OK: {name}")
134
+ start = time.time()
135
+ try:
136
+ run_shell(command, cwd=repo)
137
+ except APError as exc:
138
+ duration_s = time.time() - start
139
+ _record_gate_profile(repo, cfg, name, "fail", duration_s, detail=str(exc))
140
+ _record_evidence(repo, cfg, "command", "fail", {"name": name, "duration_s": round(duration_s, 3)})
141
+ raise
142
+ duration_s = time.time() - start
143
+ _record_gate_profile(repo, cfg, name, "pass", duration_s)
144
+ _record_evidence(repo, cfg, "command", "pass", {"name": name, "duration_s": round(duration_s, 3)})
145
+ print(f"[run] OK: {name} ({duration_s:.1f}s)")
62
146
  return True
63
147
 
64
148
 
@@ -402,6 +486,121 @@ def cmd_install(args: argparse.Namespace) -> None:
402
486
  print("[install] Next: edit docs/ENGINEERING.md frontmatter, fill all platform credentials, and commit that file into Git.")
403
487
 
404
488
 
489
+ def cmd_upgrade(args: argparse.Namespace) -> None:
490
+ repo = Path(args.repo).resolve()
491
+ ensure_git_repo(repo)
492
+ write = bool(args.write) and not bool(args.dry_run)
493
+ source_root = _find_skill_asset_root(repo)
494
+ templates = source_root / "data" / "templates"
495
+ actions: list[dict] = []
496
+
497
+ def add_action(kind: str, path: Path, action: str, detail: str = "") -> None:
498
+ actions.append({
499
+ "kind": kind,
500
+ "path": _repo_rel(repo, path),
501
+ "action": action,
502
+ "detail": detail,
503
+ })
504
+
505
+ tool_files = [
506
+ (source_root / "scripts" / "ap.py", repo / "docs" / "tools" / "autopipeline" / "ap.py"),
507
+ (source_root / "scripts" / "core.py", repo / "docs" / "tools" / "autopipeline" / "core.py"),
508
+ (source_root / "scripts" / "http_checks.py", repo / "docs" / "tools" / "autopipeline" / "http_checks.py"),
509
+ ]
510
+ for src, dst in tool_files:
511
+ if not src.exists():
512
+ continue
513
+ if not dst.exists():
514
+ add_action("tool", dst, "create")
515
+ if write:
516
+ copy_tree(src, dst)
517
+ elif _files_differ(src, dst):
518
+ add_action("tool", dst, "update")
519
+ if write:
520
+ copy_tree(src, dst)
521
+ else:
522
+ add_action("tool", dst, "ok")
523
+
524
+ project_skill = repo / ".agents" / "skills" / "auto-coding-skill"
525
+ if project_skill.exists():
526
+ for src in _iter_files(source_root):
527
+ if ".git" in src.parts:
528
+ continue
529
+ rel = src.relative_to(source_root)
530
+ dst = project_skill / rel
531
+ if not dst.exists():
532
+ add_action("skill", dst, "create")
533
+ if write:
534
+ copy_tree(src, dst)
535
+ elif _files_differ(src, dst):
536
+ add_action("skill", dst, "update")
537
+ if write:
538
+ copy_tree(src, dst)
539
+ for dst in _iter_files(project_skill):
540
+ rel = dst.relative_to(project_skill)
541
+ if not (source_root / rel).exists():
542
+ add_action("skill", dst, "extra", "present only in project copy")
543
+ else:
544
+ add_action("skill", project_skill, "missing", "run autocoding init --ai codex --mode project --force")
545
+
546
+ docs_template = templates / "docs"
547
+ for src in _iter_files(docs_template):
548
+ rel = src.relative_to(docs_template)
549
+ dst = repo / "docs" / rel
550
+ if not dst.exists():
551
+ add_action("doc", dst, "create")
552
+ if write:
553
+ copy_tree(src, dst)
554
+ elif _files_differ(src, dst) and str(rel).startswith(("architecture/", "reviews/optimization-backlog.md", "reviews/project-health-baseline.md")):
555
+ add_action("doc", dst, "stale", "kept unchanged; review manually")
556
+ else:
557
+ add_action("doc", dst, "ok")
558
+
559
+ engineering = repo / "docs" / "ENGINEERING.md"
560
+ template_engineering = templates / "ENGINEERING.md"
561
+ if engineering.exists() and template_engineering.exists():
562
+ current_cfg, body = _read_frontmatter_markdown(engineering)
563
+ template_cfg, _ = _read_frontmatter_markdown(template_engineering)
564
+ merged_cfg = json.loads(json.dumps(current_cfg))
565
+ added_keys = _deep_merge_missing(merged_cfg, template_cfg)
566
+ if added_keys:
567
+ add_action("config", engineering, "merge", ", ".join(added_keys))
568
+ if write:
569
+ _write_frontmatter_markdown(engineering, merged_cfg, body)
570
+ else:
571
+ add_action("config", engineering, "ok")
572
+ elif template_engineering.exists():
573
+ add_action("config", engineering, "create")
574
+ if write:
575
+ copy_tree(template_engineering, engineering)
576
+
577
+ result = {
578
+ "source_root": str(source_root),
579
+ "mode": "write" if write else "dry-run",
580
+ "actions": actions,
581
+ }
582
+ if args.json:
583
+ print(json.dumps(result, ensure_ascii=False, indent=2))
584
+ else:
585
+ print(f"[upgrade] source={source_root}")
586
+ print(f"[upgrade] mode={'write' if write else 'dry-run'}")
587
+ for item in actions:
588
+ if item["action"] == "ok":
589
+ continue
590
+ detail = f" - {item['detail']}" if item.get("detail") else ""
591
+ print(f"[upgrade] {item['action']} {item['kind']}: {item['path']}{detail}")
592
+ if not any(item["action"] != "ok" for item in actions):
593
+ print("[upgrade] OK: no changes needed")
594
+ elif not write:
595
+ print("[upgrade] dry-run only; re-run with --write to apply safe updates")
596
+ try:
597
+ cfg = _load_cfg(repo)
598
+ except Exception:
599
+ cfg = {}
600
+ if cfg and write:
601
+ _record_evidence(repo, cfg, "upgrade", "pass", {"mode": result["mode"], "action_count": len(actions)})
602
+
603
+
405
604
  def _infer_title(taskbook: Path, task_id: str) -> str:
406
605
  if not taskbook.exists():
407
606
  return "<Title>"
@@ -471,6 +670,8 @@ def cmd_gen_summary(args: argparse.Namespace) -> None:
471
670
  ## 4. 质量证据
472
671
  - 本地轻量校验:light_gate or quick_test/test/build / api docs / jenkins / diff-check — TODO
473
672
  - 结构检查:structure-check — TODO
673
+ - 结构化证据:docs/tasks/evidence.jsonl — TODO
674
+ - 门禁画像:.local/auto-coding-skill/gate-profile.jsonl — TODO
474
675
  - Jenkins Build:TODO
475
676
  - 目标环境验证:TODO
476
677
  - 闭环记录:TODO
@@ -556,6 +757,83 @@ def _load_cfg(repo: Path) -> dict:
556
757
  return load_yaml(cfg_path)
557
758
 
558
759
 
760
+ def _candidate_skill_roots(repo: Path) -> list[Path]:
761
+ return [
762
+ _skill_root(),
763
+ repo / ".agents" / "skills" / "auto-coding-skill",
764
+ Path.home() / ".agents" / "skills" / "auto-coding-skill",
765
+ repo / ".claude" / "skills" / "auto-coding-skill",
766
+ Path.home() / ".claude" / "skills" / "auto-coding-skill",
767
+ ]
768
+
769
+
770
+ def _find_skill_asset_root(repo: Path) -> Path:
771
+ for root in _candidate_skill_roots(repo):
772
+ if (root / "data" / "templates").exists() and (root / "scripts" / "ap.py").exists():
773
+ return root
774
+ raise APError(
775
+ "Cannot find auto-coding-skill asset root. Run `autocoding init --ai codex --mode global --force` "
776
+ "or execute this command from an installed skill copy."
777
+ )
778
+
779
+
780
+ def _file_sha256(path: Path) -> str:
781
+ if not path.exists() or not path.is_file():
782
+ return ""
783
+ h = hashlib.sha256()
784
+ with path.open("rb") as handle:
785
+ for chunk in iter(lambda: handle.read(1024 * 1024), b""):
786
+ h.update(chunk)
787
+ return h.hexdigest()
788
+
789
+
790
+ def _files_differ(a: Path, b: Path) -> bool:
791
+ return _file_sha256(a) != _file_sha256(b)
792
+
793
+
794
+ def _read_frontmatter_markdown(path: Path) -> tuple[dict, str]:
795
+ if not path.exists():
796
+ return {}, ""
797
+ text = path.read_text(encoding="utf-8")
798
+ m = re.match(r"^---\s*\n(.*?)\n---\s*(\n|$)(.*)$", text, flags=re.DOTALL)
799
+ if not m:
800
+ raise APError(f"Markdown frontmatter not found: {path}")
801
+ if yaml is None:
802
+ raise APError("PyYAML not installed. Install dependencies with: pip install pyyaml requests")
803
+ data = yaml.safe_load(m.group(1)) or {}
804
+ return data, m.group(3)
805
+
806
+
807
+ def _write_frontmatter_markdown(path: Path, data: dict, body: str) -> None:
808
+ if yaml is None:
809
+ raise APError("PyYAML not installed. Install dependencies with: pip install pyyaml requests")
810
+ dumped = yaml.safe_dump(data, allow_unicode=True, sort_keys=False).strip()
811
+ path.write_text(f"---\n{dumped}\n---\n{body}", encoding="utf-8")
812
+
813
+
814
+ def _deep_merge_missing(target: dict, template: dict, prefix: str = "") -> list[str]:
815
+ added: list[str] = []
816
+ for key, value in template.items():
817
+ field = f"{prefix}.{key}" if prefix else str(key)
818
+ if key not in target or target.get(key) is None:
819
+ target[key] = value
820
+ added.append(field)
821
+ continue
822
+ if isinstance(target.get(key), dict) and isinstance(value, dict):
823
+ added.extend(_deep_merge_missing(target[key], value, field))
824
+ return added
825
+
826
+
827
+ def _iter_files(root: Path) -> list[Path]:
828
+ if not root.exists():
829
+ return []
830
+ out: list[Path] = []
831
+ for path in root.rglob("*"):
832
+ if path.is_file() and "__pycache__" not in path.parts and path.name != ".DS_Store" and not path.name.endswith(".pyc"):
833
+ out.append(path)
834
+ return sorted(out)
835
+
836
+
559
837
  def _workflow_mode(cfg: dict, args: Optional[argparse.Namespace] = None) -> str:
560
838
  explicit = str(getattr(args, "mode", "") or "").strip().lower() if args else ""
561
839
  configured = str(((cfg.get("workflow") or {}).get("mode")) or "dev").strip().lower()
@@ -934,7 +1212,10 @@ def _run_full_gate(repo: Path, cfg: dict) -> list[str]:
934
1212
 
935
1213
  def _run_git_diff_check(repo: Path, cfg: dict) -> None:
936
1214
  print("[diff-check] git diff --check")
1215
+ start = time.time()
937
1216
  run(["git", "diff", "--check"], cwd=repo)
1217
+ _record_gate_profile(repo, cfg, "diff_check", "pass", time.time() - start)
1218
+ _record_evidence(repo, cfg, "diff_check", "pass")
938
1219
  print("[diff-check] OK")
939
1220
 
940
1221
 
@@ -1028,6 +1309,70 @@ _FUNCTION_START_RE = re.compile(
1028
1309
  r"|^\s*(?:public|private|protected|static|final|async|\s)+\s*[\w<>\[\], ?]+\s+[A-Za-z_]\w*\s*\([^;]*\)\s*\{"
1029
1310
  r"|^\s*(?:export\s+)?(?:const|let|var)\s+[A-Za-z_]\w*\s*=\s*(?:async\s*)?\([^)]*\)\s*=>"
1030
1311
  )
1312
+ _IMPORT_PATTERNS = [
1313
+ re.compile(r"^\s*import\s+(?:.+?\s+from\s+)?[\"']([^\"']+)[\"']"),
1314
+ re.compile(r"\brequire\(\s*[\"']([^\"']+)[\"']\s*\)"),
1315
+ re.compile(r"\bimport\(\s*[\"']([^\"']+)[\"']\s*\)"),
1316
+ re.compile(r"^\s*from\s+([A-Za-z_][\w.]*)\s+import\b"),
1317
+ re.compile(r"^\s*import\s+([A-Za-z_][\w.]*)(?:\s+as\s+\w+)?\s*$"),
1318
+ re.compile(r"^\s*import\s+[\"']([^\"']+)[\"']\s*$"),
1319
+ re.compile(r"^\s*[\"']([^\"']+/[^\"']*)[\"']\s*$"),
1320
+ ]
1321
+ _DEFAULT_LAYER_RULES = {
1322
+ "enabled": True,
1323
+ "block": True,
1324
+ "rules": [
1325
+ {
1326
+ "name": "domain",
1327
+ "paths": ["**/domain/**", "**/domains/**", "**/model/**", "**/models/**"],
1328
+ "forbidden_imports": [
1329
+ "**/infrastructure/**",
1330
+ "**/infra/**",
1331
+ "**/adapter/**",
1332
+ "**/repository/**",
1333
+ "**/repositories/**",
1334
+ "**/client/**",
1335
+ "**/clients/**",
1336
+ "**/controller/**",
1337
+ "**/handler/**",
1338
+ "**/page/**",
1339
+ "**/pages/**",
1340
+ "**/component/**",
1341
+ "**/components/**",
1342
+ "**/view/**",
1343
+ "**/views/**",
1344
+ ],
1345
+ },
1346
+ {
1347
+ "name": "application",
1348
+ "paths": ["**/application/**", "**/service/**", "**/services/**", "**/usecase/**", "**/usecases/**"],
1349
+ "forbidden_imports": [
1350
+ "**/controller/**",
1351
+ "**/handler/**",
1352
+ "**/page/**",
1353
+ "**/pages/**",
1354
+ "**/component/**",
1355
+ "**/components/**",
1356
+ "**/view/**",
1357
+ "**/views/**",
1358
+ ],
1359
+ },
1360
+ {
1361
+ "name": "shared",
1362
+ "paths": ["**/shared/**", "**/common/**", "**/utils/**", "**/lib/**"],
1363
+ "forbidden_imports": [
1364
+ "**/domain/**",
1365
+ "**/application/**",
1366
+ "**/service/**",
1367
+ "**/services/**",
1368
+ "**/infrastructure/**",
1369
+ "**/controller/**",
1370
+ "**/page/**",
1371
+ "**/pages/**",
1372
+ ],
1373
+ },
1374
+ ],
1375
+ }
1031
1376
 
1032
1377
 
1033
1378
  def _structure_cfg(cfg: dict) -> dict:
@@ -1164,6 +1509,85 @@ def _function_size_warnings(path: str, lines: list[str], threshold: int) -> list
1164
1509
  return warnings
1165
1510
 
1166
1511
 
1512
+ def _layer_rules_config(structure_cfg: dict) -> dict:
1513
+ raw = structure_cfg.get("layer_rules")
1514
+ if not isinstance(raw, dict):
1515
+ return dict(_DEFAULT_LAYER_RULES)
1516
+ merged = dict(_DEFAULT_LAYER_RULES)
1517
+ merged.update(raw)
1518
+ if "rules" not in raw:
1519
+ merged["rules"] = _DEFAULT_LAYER_RULES["rules"]
1520
+ return merged
1521
+
1522
+
1523
+ def _extract_import_targets(path: str, lines: list[str]) -> list[tuple[int, str]]:
1524
+ suffix = Path(path).suffix.lower()
1525
+ if suffix not in {".py", ".js", ".jsx", ".ts", ".tsx", ".vue", ".go", ".java", ".kt", ".kts", ".rs", ".swift"}:
1526
+ return []
1527
+ targets: list[tuple[int, str]] = []
1528
+ for index, line in enumerate(lines):
1529
+ stripped = line.strip()
1530
+ if not stripped or stripped.startswith(("#", "//", "*")):
1531
+ continue
1532
+ for pattern in _IMPORT_PATTERNS:
1533
+ match = pattern.search(line)
1534
+ if match:
1535
+ targets.append((index + 1, match.group(1).strip()))
1536
+ break
1537
+ return targets
1538
+
1539
+
1540
+ def _resolve_relative_import(source_path: str, target: str) -> str:
1541
+ normalized = target.replace("\\", "/")
1542
+ if not normalized.startswith("."):
1543
+ return normalized
1544
+ source_dir = Path(source_path).parent
1545
+ parts = []
1546
+ for part in (source_dir / normalized).parts:
1547
+ if part in {"", "."}:
1548
+ continue
1549
+ if part == "..":
1550
+ if parts:
1551
+ parts.pop()
1552
+ continue
1553
+ parts.append(part)
1554
+ return "/".join(parts)
1555
+
1556
+
1557
+ def _import_matches_pattern(target: str, pattern: str) -> bool:
1558
+ normalized = target.replace("\\", "/").lstrip("./")
1559
+ dotted_as_path = normalized.replace(".", "/")
1560
+ pat = pattern.replace("\\", "/").lstrip("./")
1561
+ if _path_matches(normalized, [pat]) or _path_matches(dotted_as_path, [pat]):
1562
+ return True
1563
+ marker = pat.replace("**/", "").replace("/**", "").strip("/")
1564
+ if marker and (f"/{marker}/" in f"/{normalized}/" or f"/{marker}/" in f"/{dotted_as_path}/"):
1565
+ return True
1566
+ return False
1567
+
1568
+
1569
+ def _structure_boundary_issues(path: str, lines: list[str], structure_cfg: dict) -> list[str]:
1570
+ layer_cfg = _layer_rules_config(structure_cfg)
1571
+ if not _bool_config(layer_cfg.get("enabled"), True):
1572
+ return []
1573
+ rules = [rule for rule in _as_list(layer_cfg.get("rules")) if isinstance(rule, dict)]
1574
+ if not rules:
1575
+ return []
1576
+ matching_rules = [rule for rule in rules if _path_matches(path, _as_list(rule.get("paths")))]
1577
+ if not matching_rules:
1578
+ return []
1579
+ imports = _extract_import_targets(path, lines)
1580
+ issues: list[str] = []
1581
+ for rule in matching_rules:
1582
+ name = _text(rule.get("name")) or "layer"
1583
+ forbidden = _as_list(rule.get("forbidden_imports"))
1584
+ for line_no, target in imports:
1585
+ resolved = _resolve_relative_import(path, target)
1586
+ if any(_import_matches_pattern(target, pattern) or _import_matches_pattern(resolved, pattern) for pattern in forbidden):
1587
+ issues.append(f"{path}:{line_no} layer '{name}' imports forbidden target '{target}'")
1588
+ return issues
1589
+
1590
+
1167
1591
  def _configured_structure_docs(cfg: dict) -> dict[str, str]:
1168
1592
  docs_cfg = cfg.get("docs") or {}
1169
1593
  return {
@@ -1209,6 +1633,8 @@ def cmd_structure_check(args: argparse.Namespace) -> None:
1209
1633
  warn_function_lines = _int_config(structure_cfg.get("max_function_lines_warn"), 120)
1210
1634
  max_added_to_large = _int_config(structure_cfg.get("max_added_lines_to_large_file"), 80)
1211
1635
  block_large_growth = _bool_config(structure_cfg.get("block_new_responsibility_in_large_file"), True)
1636
+ layer_cfg = _layer_rules_config(structure_cfg)
1637
+ block_layer_violations = _bool_config(layer_cfg.get("block"), True)
1212
1638
 
1213
1639
  paths = _structure_paths_for_scope(repo, selected_scope, base_ref, structure_cfg)
1214
1640
  added_by_path = _added_lines_by_path(repo, base_ref=base_ref) if selected_scope != "full" else {}
@@ -1248,6 +1674,11 @@ def cmd_structure_check(args: argparse.Namespace) -> None:
1248
1674
  )
1249
1675
 
1250
1676
  warnings.extend(_function_size_warnings(path, lines, warn_function_lines))
1677
+ boundary_issues = _structure_boundary_issues(path, lines, structure_cfg)
1678
+ if block_layer_violations:
1679
+ blocking.extend(boundary_issues)
1680
+ else:
1681
+ warnings.extend(boundary_issues)
1251
1682
 
1252
1683
  missing_docs: list[str] = []
1253
1684
  for key, rel_path in _configured_structure_docs(cfg).items():
@@ -1272,8 +1703,10 @@ def cmd_structure_check(args: argparse.Namespace) -> None:
1272
1703
  _print_limited("[structure-check] warnings", warnings)
1273
1704
 
1274
1705
  if blocking:
1706
+ _record_evidence(repo, cfg, "structure_check", "fail", result)
1275
1707
  raise APError(f"structure-check failed with {len(blocking)} blocking issue(s)")
1276
1708
 
1709
+ _record_evidence(repo, cfg, "structure_check", "pass", result)
1277
1710
  if not getattr(args, "json", False):
1278
1711
  print(f"[structure-check] OK scope={selected_scope} inspected={inspected} warnings={len(warnings)}")
1279
1712
 
@@ -1295,6 +1728,370 @@ def _run_structure_check_for_gate(repo: Path, cfg: dict, selected_scope: str, ba
1295
1728
  return ["structure_check"]
1296
1729
 
1297
1730
 
1731
+ def _current_git_ref(repo: Path) -> str:
1732
+ value = run(["git", "rev-parse", "--short=12", "HEAD"], cwd=repo, check=False).stdout.strip()
1733
+ return value or "uncommitted"
1734
+
1735
+
1736
+ def _directory_hotspots(paths: list[str]) -> list[tuple[str, int]]:
1737
+ counts: dict[str, int] = {}
1738
+ for path in paths:
1739
+ parts = path.split("/")
1740
+ if len(parts) <= 1:
1741
+ key = "."
1742
+ elif parts[0] in {"frontend", "backend", "packages", "apps", "services"} and len(parts) >= 3:
1743
+ key = "/".join(parts[:3])
1744
+ else:
1745
+ key = "/".join(parts[:2])
1746
+ counts[key] = counts.get(key, 0) + 1
1747
+ return sorted(counts.items(), key=lambda item: (-item[1], item[0]))[:20]
1748
+
1749
+
1750
+ def _scan_structure_inventory(repo: Path, cfg: dict) -> dict:
1751
+ structure_cfg = _structure_cfg(cfg)
1752
+ warn_file_lines = _int_config(structure_cfg.get("max_file_lines_warn"), 800)
1753
+ block_file_lines = _int_config(structure_cfg.get("max_file_lines_block"), 1500)
1754
+ paths = [path for path in _tracked_files(repo) if _is_structure_candidate(path, structure_cfg)]
1755
+ large_files: list[dict] = []
1756
+ for path in paths:
1757
+ lines = _read_text_lines(repo, path)
1758
+ if lines is None:
1759
+ continue
1760
+ line_count = len(lines)
1761
+ if line_count > warn_file_lines:
1762
+ large_files.append({
1763
+ "path": path,
1764
+ "lines": line_count,
1765
+ "priority": "P1" if block_file_lines > 0 and line_count > block_file_lines else "P2",
1766
+ })
1767
+ large_files.sort(key=lambda item: (-int(item["lines"]), str(item["path"])))
1768
+ return {
1769
+ "files_inspected": len(paths),
1770
+ "large_files": large_files,
1771
+ "hotspots": _directory_hotspots(paths),
1772
+ }
1773
+
1774
+
1775
+ def _render_health_baseline(repo: Path, cfg: dict, inventory: dict) -> str:
1776
+ date = _dt.date.today().isoformat()
1777
+ commit = _current_git_ref(repo)
1778
+ large_rows = "\n".join(
1779
+ f"| `{item['path']}` | {item['lines']} lines | Accepted for baseline; no large new additions without extraction | {date} |"
1780
+ for item in inventory["large_files"][:30]
1781
+ ) or "| (none) | | | |"
1782
+ debt_rows = "\n".join(
1783
+ f"| DEBT-{idx:03d} | {item['priority']} | `{item['path']}` | Large file baseline: {item['lines']} lines | Existing state at baseline | New large additions or touched feature work |"
1784
+ for idx, item in enumerate(inventory["large_files"][:30], start=1)
1785
+ ) or "| (none) | | | | | |"
1786
+ return f"""# Project Health Baseline
1787
+
1788
+ > Generated by `ap.py baseline init`. Update this file when accepted structure debt changes.
1789
+
1790
+ - Baseline date: {date}
1791
+ - Baseline commit: `{commit}`
1792
+ - Owner: TODO
1793
+ - Review scope: repo
1794
+ - Standard: `docs/architecture/structure-standard.md`
1795
+ - Files inspected: {inventory['files_inspected']}
1796
+
1797
+ ## 1. Current Accepted Structure
1798
+
1799
+ | Area | Current state | Accepted because | Review date |
1800
+ | --- | --- | --- | --- |
1801
+ {large_rows}
1802
+
1803
+ ## 2. Closed Optimization Scope
1804
+
1805
+ | ID | Closed date | Scope | Acceptance evidence |
1806
+ | --- | --- | --- | --- |
1807
+ | (none) | | | |
1808
+
1809
+ ## 3. Accepted Debt
1810
+
1811
+ | ID | Priority | Scope | Debt | Why accepted | Revisit trigger |
1812
+ | --- | --- | --- | --- | --- | --- |
1813
+ {debt_rows}
1814
+
1815
+ ## 4. Priority Rules
1816
+
1817
+ - P0: blocks build, release, deploy, core user flow, data integrity, security, or compliance.
1818
+ - P1: clear architectural violation, contract drift, missing test around high-risk change, or recently introduced maintainability risk.
1819
+ - P2: planned debt such as large files, hot directories, module extraction, stronger tests, or tool consolidation.
1820
+ - P3: optional naming, style, polish, or further abstraction.
1821
+
1822
+ ## 5. Completion Standard
1823
+
1824
+ An optimization task is complete when all are true:
1825
+
1826
+ - The scoped P0/P1/P2 items listed for this task are closed.
1827
+ - Local gate passed, including structure check when enabled.
1828
+ - No new unclassified P0/P1 was introduced.
1829
+ - Remaining P2/P3 items are either in `docs/reviews/optimization-backlog.md` or accepted debt above.
1830
+ - Review output says explicitly whether the project meets this baseline.
1831
+
1832
+ ## 6. New Review Instructions
1833
+
1834
+ - Read this baseline first.
1835
+ - Read `docs/reviews/optimization-backlog.md` second.
1836
+ - Report only new or worsened issues, unrecorded P0/P1, priority upgrades, or baseline drift.
1837
+ """
1838
+
1839
+
1840
+ def _render_optimization_backlog(inventory: dict) -> str:
1841
+ date = _dt.date.today().isoformat()
1842
+ rows = "\n".join(
1843
+ f"| OPT-{idx:03d} | {item['priority']} | accepted-debt | `{item['path']}` | Split or reduce {item['lines']}-line file | Existing large file baseline | No new responsibilities; extract during touched feature work | {date} |"
1844
+ for idx, item in enumerate(inventory["large_files"][:30], start=1)
1845
+ ) or "| (none) | | | | | | | |"
1846
+ hotspot_rows = "\n".join(
1847
+ f"| HOT-{idx:03d} | P3 | open | `{path}` | Review module cohesion ({count} tracked source files) | Hotspot directory | Split only when feature work naturally touches this area | {date} |"
1848
+ for idx, (path, count) in enumerate(inventory["hotspots"][:10], start=1)
1849
+ )
1850
+ if hotspot_rows:
1851
+ rows = rows + "\n" + hotspot_rows
1852
+ return f"""# Optimization Backlog
1853
+
1854
+ > Generated by `ap.py baseline init`. Accepted debt is not a current-task failure unless it worsens or is touched by new feature work.
1855
+
1856
+ ## Status Values
1857
+
1858
+ - `open`: confirmed and waiting for planning.
1859
+ - `accepted-debt`: accepted current debt with a revisit trigger.
1860
+ - `in-progress`: currently being handled.
1861
+ - `closed`: completed with evidence.
1862
+ - `superseded`: replaced by another item.
1863
+
1864
+ ## Backlog
1865
+
1866
+ | ID | Priority | Status | Scope | Item | Reason | Acceptance | Last reviewed |
1867
+ | --- | --- | --- | --- | --- | --- | --- | --- |
1868
+ {rows}
1869
+
1870
+ ## Review Rules
1871
+
1872
+ - P0/P1 cannot remain in backlog without immediate owner and plan.
1873
+ - P2 needs scope, reason, and acceptance.
1874
+ - P3 does not block completion.
1875
+ - New reviews update existing rows instead of duplicating equivalent findings.
1876
+ """
1877
+
1878
+
1879
+ def _update_accepted_debt_paths(repo: Path, cfg: dict, paths: list[str]) -> list[str]:
1880
+ if not paths:
1881
+ return []
1882
+ engineering = find_config(repo)
1883
+ current_cfg, body = _read_frontmatter_markdown(engineering)
1884
+ structure_cfg = current_cfg.setdefault("structure", {})
1885
+ existing = [str(item) for item in _as_list(structure_cfg.get("accepted_debt_paths")) if str(item).strip()]
1886
+ added = [path for path in paths if path not in existing]
1887
+ if added:
1888
+ structure_cfg["accepted_debt_paths"] = existing + added
1889
+ _write_frontmatter_markdown(engineering, current_cfg, body)
1890
+ return added
1891
+
1892
+
1893
+ def cmd_baseline_init(args: argparse.Namespace) -> None:
1894
+ repo = Path(args.repo).resolve()
1895
+ ensure_git_repo(repo)
1896
+ cfg = _load_cfg(repo)
1897
+ docs_cfg = cfg.get("docs") or {}
1898
+ inventory = _scan_structure_inventory(repo, cfg)
1899
+ health_path = Path(repo, _text(docs_cfg.get("health_baseline")) or "docs/reviews/project-health-baseline.md")
1900
+ backlog_path = Path(repo, _text(docs_cfg.get("optimization_backlog")) or "docs/reviews/optimization-backlog.md")
1901
+ write = bool(args.write)
1902
+ force = bool(args.force)
1903
+ update_config = bool(args.update_config)
1904
+
1905
+ actions: list[dict] = []
1906
+ for path, content, label in [
1907
+ (health_path, _render_health_baseline(repo, cfg, inventory), "health_baseline"),
1908
+ (backlog_path, _render_optimization_backlog(inventory), "optimization_backlog"),
1909
+ ]:
1910
+ if path.exists() and not force:
1911
+ actions.append({"path": _repo_rel(repo, path), "action": "exists", "kind": label})
1912
+ continue
1913
+ actions.append({"path": _repo_rel(repo, path), "action": "write" if write else "would-write", "kind": label})
1914
+ if write:
1915
+ path.parent.mkdir(parents=True, exist_ok=True)
1916
+ path.write_text(content, encoding="utf-8")
1917
+
1918
+ accepted_added: list[str] = []
1919
+ accepted_paths = [str(item["path"]) for item in inventory["large_files"] if item["priority"] in {"P1", "P2"}]
1920
+ if write and update_config:
1921
+ accepted_added = _update_accepted_debt_paths(repo, cfg, accepted_paths)
1922
+ if accepted_added:
1923
+ actions.append({
1924
+ "path": "docs/ENGINEERING.md",
1925
+ "action": "merge",
1926
+ "kind": "accepted_debt_paths",
1927
+ "detail": ", ".join(accepted_added),
1928
+ })
1929
+
1930
+ result = {
1931
+ "files_inspected": inventory["files_inspected"],
1932
+ "large_files": inventory["large_files"],
1933
+ "hotspots": inventory["hotspots"],
1934
+ "actions": actions,
1935
+ "updated_accepted_debt_paths": accepted_added,
1936
+ }
1937
+ if args.json:
1938
+ print(json.dumps(result, ensure_ascii=False, indent=2))
1939
+ else:
1940
+ print(f"[baseline] files_inspected={inventory['files_inspected']}")
1941
+ print(f"[baseline] large_files={len(inventory['large_files'])}")
1942
+ for item in actions:
1943
+ detail = f" - {item.get('detail')}" if item.get("detail") else ""
1944
+ print(f"[baseline] {item['action']} {item['kind']}: {item['path']}{detail}")
1945
+ if not write:
1946
+ print("[baseline] dry-run only; re-run with --write to create baseline files")
1947
+
1948
+ if write:
1949
+ _record_evidence(
1950
+ repo,
1951
+ cfg,
1952
+ "baseline_init",
1953
+ "pass",
1954
+ {"write": write, "large_file_count": len(inventory["large_files"]), "files_inspected": inventory["files_inspected"]},
1955
+ )
1956
+
1957
+
1958
+ def _read_jsonl(path: Path) -> list[dict]:
1959
+ if not path.exists():
1960
+ return []
1961
+ records: list[dict] = []
1962
+ for line in path.read_text(encoding="utf-8").splitlines():
1963
+ if not line.strip():
1964
+ continue
1965
+ try:
1966
+ records.append(json.loads(line))
1967
+ except json.JSONDecodeError:
1968
+ continue
1969
+ return records
1970
+
1971
+
1972
+ def cmd_gate_profile(args: argparse.Namespace) -> None:
1973
+ repo = Path(args.repo).resolve()
1974
+ cfg = _load_cfg(repo)
1975
+ records = _read_jsonl(_gate_profile_path(repo, cfg))
1976
+ limit = int(args.limit or 20)
1977
+ by_name: dict[str, dict] = {}
1978
+ for record in records:
1979
+ name = _text(record.get("name")) or "(unknown)"
1980
+ bucket = by_name.setdefault(name, {"name": name, "runs": 0, "failures": 0, "total_duration_s": 0.0, "max_duration_s": 0.0})
1981
+ duration = float(record.get("duration_s") or 0)
1982
+ bucket["runs"] += 1
1983
+ bucket["total_duration_s"] += duration
1984
+ bucket["max_duration_s"] = max(float(bucket["max_duration_s"]), duration)
1985
+ if _text(record.get("status")) != "pass":
1986
+ bucket["failures"] += 1
1987
+ summary = []
1988
+ for bucket in by_name.values():
1989
+ runs = int(bucket["runs"])
1990
+ total = float(bucket["total_duration_s"])
1991
+ summary.append({
1992
+ "name": bucket["name"],
1993
+ "runs": runs,
1994
+ "failures": int(bucket["failures"]),
1995
+ "failure_rate": round(int(bucket["failures"]) / runs, 3) if runs else 0,
1996
+ "avg_duration_s": round(total / runs, 3) if runs else 0,
1997
+ "max_duration_s": round(float(bucket["max_duration_s"]), 3),
1998
+ })
1999
+ summary.sort(key=lambda item: (-float(item["avg_duration_s"]), str(item["name"])))
2000
+ result = {"profile_log": str(_gate_profile_path(repo, cfg)), "commands": summary[:limit], "record_count": len(records)}
2001
+ if args.json:
2002
+ print(json.dumps(result, ensure_ascii=False, indent=2))
2003
+ else:
2004
+ print(f"[gate-profile] log={result['profile_log']}")
2005
+ print(f"[gate-profile] records={len(records)}")
2006
+ if not summary:
2007
+ print("[gate-profile] no profile records yet; run light-gate or configured commands first")
2008
+ for item in summary[:limit]:
2009
+ print(
2010
+ f"[gate-profile] {item['name']}: runs={item['runs']} "
2011
+ f"avg={item['avg_duration_s']}s max={item['max_duration_s']}s failures={item['failures']}"
2012
+ )
2013
+
2014
+
2015
+ def _classify_paths(paths: list[str]) -> dict:
2016
+ categories: set[str] = set()
2017
+ for path in paths:
2018
+ lower = path.lower()
2019
+ if _path_matches(path, _DEFAULT_FULL_PATH_PATTERNS):
2020
+ categories.add("release_or_tooling")
2021
+ if any(token in lower for token in ["migration", "schema", "database", "/db/", "/sql/"]) or lower.endswith(".sql"):
2022
+ categories.add("db")
2023
+ if any(token in lower for token in ["api", "controller", "handler", "route", "server"]):
2024
+ categories.add("api")
2025
+ if any(token in lower for token in ["auth", "permission", "role", "tenant", "security"]):
2026
+ categories.add("auth")
2027
+ if any(token in lower for token in ["page", "component", "view", "frontend", "miniapp", ".tsx", ".jsx", ".vue", ".scss", ".css"]):
2028
+ categories.add("ui")
2029
+ if any(token in lower for token in ["test", "spec", "__tests__"]):
2030
+ categories.add("test")
2031
+ if lower.startswith("docs/") or lower.endswith(".md"):
2032
+ categories.add("docs")
2033
+ if any(token in lower for token in ["domain", "service", "usecase", "repository", "infrastructure", "adapter", "shared", "utils"]):
2034
+ categories.add("structure")
2035
+ return {
2036
+ "categories": sorted(categories),
2037
+ "needs_dd": bool(categories & {"api", "db", "auth", "release_or_tooling"}) or len(paths) > 12,
2038
+ "needs_adr": bool(categories & {"structure", "release_or_tooling"}) and not categories <= {"docs"},
2039
+ "needs_browser": "ui" in categories,
2040
+ "needs_jenkins": bool(categories & {"release_or_tooling", "db", "auth"}),
2041
+ "needs_target": bool(categories & {"api", "db", "auth", "ui"}),
2042
+ }
2043
+
2044
+
2045
+ def cmd_classify(args: argparse.Namespace) -> None:
2046
+ repo = Path(args.repo).resolve()
2047
+ cfg = _load_cfg(repo)
2048
+ scope = str(args.scope or "").strip().lower()
2049
+ impact = _impact_summary(cfg, repo, requested_scope=scope, base_ref=str(args.base or ""))
2050
+ paths = list(impact.get("changed_files") or [])
2051
+ path_classification = _classify_paths(paths)
2052
+ selected_scope = str(impact["selected_scope"])
2053
+ risk = "P3"
2054
+ if path_classification["needs_jenkins"] or selected_scope == "full":
2055
+ risk = "P1"
2056
+ elif path_classification["needs_target"] or path_classification["needs_dd"]:
2057
+ risk = "P2"
2058
+ elif not paths:
2059
+ risk = "P3"
2060
+ commands = [
2061
+ "python3 docs/tools/autopipeline/ap.py impact --scope auto",
2062
+ "python3 docs/tools/autopipeline/ap.py structure-check --scope auto",
2063
+ f"python3 docs/tools/autopipeline/ap.py light-gate --scope {selected_scope} --explain",
2064
+ ]
2065
+ if path_classification["needs_jenkins"]:
2066
+ commands.append("python3 docs/tools/autopipeline/ap.py verify-jenkins")
2067
+ result = {
2068
+ "requested_scope": impact["requested_scope"],
2069
+ "selected_scope": selected_scope,
2070
+ "risk": risk,
2071
+ "changed_files": paths,
2072
+ "categories": path_classification["categories"],
2073
+ "needs_dd": path_classification["needs_dd"],
2074
+ "needs_adr": path_classification["needs_adr"],
2075
+ "needs_browser": path_classification["needs_browser"],
2076
+ "needs_jenkins": path_classification["needs_jenkins"],
2077
+ "needs_target": path_classification["needs_target"],
2078
+ "recommended_commands": commands,
2079
+ "reasons": impact.get("reasons") or [],
2080
+ "matched_rules": impact.get("matched_rules") or [],
2081
+ }
2082
+ if args.json:
2083
+ print(json.dumps(result, ensure_ascii=False, indent=2))
2084
+ else:
2085
+ print(f"[classify] risk={risk}")
2086
+ print(f"[classify] selected_scope={selected_scope}")
2087
+ print("[classify] categories=" + (", ".join(result["categories"]) or "(none)"))
2088
+ for key in ["needs_dd", "needs_adr", "needs_browser", "needs_jenkins", "needs_target"]:
2089
+ print(f"[classify] {key}={result[key]}")
2090
+ for command in commands:
2091
+ print(f"[classify] command: {command}")
2092
+ _record_evidence(repo, cfg, "classify", "pass", result)
2093
+
2094
+
1298
2095
  def cmd_run(args: argparse.Namespace) -> None:
1299
2096
  """
1300
2097
  Run any configured gate command by name.
@@ -1320,6 +2117,7 @@ def cmd_run(args: argparse.Namespace) -> None:
1320
2117
 
1321
2118
  def cmd_light_gate(args: argparse.Namespace) -> None:
1322
2119
  repo = Path(args.repo).resolve()
2120
+ light_gate_start = time.time()
1323
2121
  cmd_doctor(argparse.Namespace(repo=str(repo)))
1324
2122
  cfg = _load_cfg(repo)
1325
2123
  requested_scope = str(getattr(args, "scope", "") or "").strip().lower()
@@ -1344,6 +2142,15 @@ def cmd_light_gate(args: argparse.Namespace) -> None:
1344
2142
  cmd_verify_api_docs(argparse.Namespace(repo=str(repo)))
1345
2143
  cmd_verify_jenkins(argparse.Namespace(repo=str(repo)))
1346
2144
  executed.extend(["diff_check", "verify_api_docs", "verify_jenkins"])
2145
+ duration_s = time.time() - light_gate_start
2146
+ _record_gate_profile(repo, cfg, "light_gate", "pass", duration_s, scope=selected_scope, detail=", ".join(executed))
2147
+ _record_evidence(
2148
+ repo,
2149
+ cfg,
2150
+ "light_gate",
2151
+ "pass",
2152
+ {"scope": selected_scope, "executed": executed, "duration_s": round(duration_s, 3), "changed_files": paths},
2153
+ )
1347
2154
  print(f"[light-gate] OK scope={selected_scope}: " + ", ".join(executed))
1348
2155
 
1349
2156
 
@@ -1353,6 +2160,7 @@ def cmd_impact(args: argparse.Namespace) -> None:
1353
2160
  scope = str(args.scope or "").strip().lower()
1354
2161
  summary = _impact_summary(cfg, repo, requested_scope=scope, base_ref=str(args.base or ""))
1355
2162
  _print_impact(summary, as_json=bool(args.json))
2163
+ _record_evidence(repo, cfg, "impact", "pass", summary)
1356
2164
 
1357
2165
 
1358
2166
  def cmd_runtime_up(args: argparse.Namespace) -> None:
@@ -1458,6 +2266,7 @@ def cmd_verify_target(args: argparse.Namespace) -> None:
1458
2266
  checks.append(f"frontend:{url}->{status}")
1459
2267
 
1460
2268
  summary = ", ".join(checks) if checks else "health-only"
2269
+ _record_evidence(repo, cfg, "verify_target", "pass", {"summary": summary, "checks": checks})
1461
2270
  print(f"[verify-target] OK: {summary}")
1462
2271
  return summary
1463
2272
 
@@ -1485,6 +2294,7 @@ def cmd_verify_jenkins(args: argparse.Namespace) -> None:
1485
2294
  missing = [name for name, value in required if not str(value or "").strip()]
1486
2295
  if missing:
1487
2296
  raise APError("Missing Jenkins config: " + ", ".join(missing))
2297
+ _record_evidence(repo, cfg, "verify_jenkins", "pass", {"jenkinsfile": str(jenkinsfile)})
1488
2298
  print(f"[verify-jenkins] OK: {jenkinsfile}")
1489
2299
 
1490
2300
 
@@ -1575,8 +2385,10 @@ def cmd_doctor(args: argparse.Namespace) -> None:
1575
2385
  missing.extend(validation_errors)
1576
2386
 
1577
2387
  if missing:
2388
+ _record_evidence(repo, cfg, "doctor", "fail", {"issues": missing})
1578
2389
  raise APError("Doctor found blocking config issues:\n- " + "\n- ".join(missing))
1579
2390
 
2391
+ _record_evidence(repo, cfg, "doctor", "pass", {"mode": mode})
1580
2392
  print("[doctor] OK")
1581
2393
 
1582
2394
 
@@ -1643,6 +2455,13 @@ def cmd_verify_jenkins_build(args: argparse.Namespace) -> None:
1643
2455
  args.allow_no_deploy,
1644
2456
  )
1645
2457
  build_url = str(payload.get("url") or "").strip()
2458
+ _record_evidence(
2459
+ repo,
2460
+ cfg,
2461
+ "verify_jenkins_build",
2462
+ "pass",
2463
+ {"job": job_label, "build": payload.get("number"), "result": result, "url": build_url},
2464
+ )
1646
2465
  print(
1647
2466
  "[verify-jenkins-build] OK: "
1648
2467
  f"job={job_label} "
@@ -1683,6 +2502,13 @@ def cmd_verify_jenkins_build(args: argparse.Namespace) -> None:
1683
2502
  args.allow_no_deploy,
1684
2503
  )
1685
2504
  build_url = str(matched.get("url") or "").strip()
2505
+ _record_evidence(
2506
+ repo,
2507
+ cfg,
2508
+ "verify_jenkins_build",
2509
+ "pass",
2510
+ {"commit": git_short_sha, "job": job_label, "build": matched.get("number"), "result": result, "url": build_url},
2511
+ )
1686
2512
  print(
1687
2513
  "[verify-jenkins-build] OK: "
1688
2514
  f"commit={git_short_sha} "
@@ -1705,6 +2531,7 @@ def cmd_verify_api_docs(args: argparse.Namespace) -> None:
1705
2531
  missing = [p for p in [api_doc, change_log] if not p.exists()]
1706
2532
  if missing:
1707
2533
  raise APError("Missing API docs: " + ", ".join([str(p) for p in missing]))
2534
+ _record_evidence(repo, cfg, "verify_api_docs", "pass", {"api_doc": str(api_doc), "api_change_log": str(change_log)})
1708
2535
  print(f"[verify-api-docs] OK: {api_doc} + {change_log}")
1709
2536
 
1710
2537
 
@@ -1754,6 +2581,13 @@ def cmd_record_closure(args: argparse.Namespace) -> None:
1754
2581
  f.write("\n")
1755
2582
  f.write("\n".join(lines))
1756
2583
  f.write("\n")
2584
+ _record_evidence(
2585
+ repo,
2586
+ cfg,
2587
+ "record_closure",
2588
+ "pass",
2589
+ {"task_id": task_id, "result": args.result, "commit": commit_value, "structure_check": structure_check},
2590
+ )
1757
2591
  print(f"[record-closure] OK: {closure_log}")
1758
2592
 
1759
2593
 
@@ -1909,6 +2743,21 @@ def main(argv: Optional[List[str]] = None) -> int:
1909
2743
  s.add_argument("--bridges", action="store_true")
1910
2744
  s.set_defaults(func=cmd_install)
1911
2745
 
2746
+ s = sp.add_parser("upgrade")
2747
+ s.add_argument("--dry-run", action="store_true")
2748
+ s.add_argument("--write", action="store_true")
2749
+ s.add_argument("--json", action="store_true")
2750
+ s.set_defaults(func=cmd_upgrade)
2751
+
2752
+ s = sp.add_parser("baseline")
2753
+ baseline_sp = s.add_subparsers(dest="baseline_cmd", required=True)
2754
+ b = baseline_sp.add_parser("init")
2755
+ b.add_argument("--write", action="store_true")
2756
+ b.add_argument("--force", action="store_true")
2757
+ b.add_argument("--update-config", action="store_true")
2758
+ b.add_argument("--json", action="store_true")
2759
+ b.set_defaults(func=cmd_baseline_init)
2760
+
1912
2761
  s = sp.add_parser("gen-summary")
1913
2762
  s.add_argument("task_id")
1914
2763
  s.add_argument("--title")
@@ -1928,12 +2777,23 @@ def main(argv: Optional[List[str]] = None) -> int:
1928
2777
  s.add_argument("--json", action="store_true")
1929
2778
  s.set_defaults(func=cmd_impact)
1930
2779
 
2780
+ s = sp.add_parser("classify")
2781
+ s.add_argument("--scope", choices=sorted(_GATE_SCOPES), default="")
2782
+ s.add_argument("--base")
2783
+ s.add_argument("--json", action="store_true")
2784
+ s.set_defaults(func=cmd_classify)
2785
+
1931
2786
  s = sp.add_parser("structure-check")
1932
2787
  s.add_argument("--scope", choices=sorted(_GATE_SCOPES), default="")
1933
2788
  s.add_argument("--base")
1934
2789
  s.add_argument("--json", action="store_true")
1935
2790
  s.set_defaults(func=cmd_structure_check)
1936
2791
 
2792
+ s = sp.add_parser("gate-profile")
2793
+ s.add_argument("--limit", type=int, default=20)
2794
+ s.add_argument("--json", action="store_true")
2795
+ s.set_defaults(func=cmd_gate_profile)
2796
+
1937
2797
  s = sp.add_parser("light-gate")
1938
2798
  s.add_argument("--scope", choices=sorted(_GATE_SCOPES), default="")
1939
2799
  s.add_argument("--base")