@elvis1513/auto-coding-skill 4.2.0 → 4.2.2
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.
- package/README.md +120 -12
- package/cli/assets/agents/reviewer.toml +35 -13
- package/cli/assets/managed-install.json +1 -1
- package/cli/assets/skill/SKILL.md +25 -21
- package/cli/assets/skill/data/contracts/orchestration-v1.schema.json +22 -0
- package/cli/assets/skill/data/policies/workflow-migrations-v1.json +2 -2
- package/cli/assets/skill/data/templates/ENGINEERING.md +3 -3
- package/cli/assets/skill/data/templates/bridges/AGENTS.md +21 -13
- package/cli/assets/skill/scripts/ap.py +1834 -185
- package/cli/assets/skill/scripts/core.py +2 -2
- package/cli/assets/skill/scripts/install_integrity.py +1 -0
- package/cli/assets/skill/scripts/scaffold_templates.py +0 -1
- package/cli/tests/ap_concurrency_test.py +340 -2
- package/cli/tests/ap_profiles_test.py +847 -0
- package/cli/tests/core_shell_test.py +84 -0
- package/cli/tests/index.test.js +135 -20
- package/package.json +2 -2
|
@@ -127,9 +127,9 @@ def find_config(repo: Path) -> Path:
|
|
|
127
127
|
|
|
128
128
|
|
|
129
129
|
def run_shell(command: str, cwd: Optional[Path] = None, timeout_s: Optional[float] = None) -> None:
|
|
130
|
-
"""Run
|
|
130
|
+
"""Run in the caller's environment and terminate the process group on timeout."""
|
|
131
131
|
p = subprocess.Popen(
|
|
132
|
-
["bash", "-
|
|
132
|
+
["bash", "-c", command],
|
|
133
133
|
cwd=str(cwd) if cwd else None,
|
|
134
134
|
text=True,
|
|
135
135
|
start_new_session=True,
|
|
@@ -225,6 +225,7 @@ def build_manifest(skill_root: Path, agents_root: Path, version: str) -> dict[st
|
|
|
225
225
|
".agents/archive/**",
|
|
226
226
|
".agents/agents/* (except paths listed in entries)",
|
|
227
227
|
"docs/project/**",
|
|
228
|
+
"docs/architecture/structure-standard.md",
|
|
228
229
|
"docs/architecture/adr/[0-9]*.md",
|
|
229
230
|
"docs/design/*.md",
|
|
230
231
|
"docs/interfaces/*.md",
|
|
@@ -157,7 +157,6 @@ Only executed checks may be marked PASS.
|
|
|
157
157
|
|
|
158
158
|
|
|
159
159
|
MANAGED_FRAMEWORK_DOCS = frozenset({
|
|
160
|
-
"docs/architecture/structure-standard.md",
|
|
161
160
|
"docs/architecture/adr/_TEMPLATE-ADR.md",
|
|
162
161
|
"docs/deployment/deploy-records/_TEMPLATE-DEPLOY-RECORD.md",
|
|
163
162
|
"docs/design/_TEMPLATE-DD.md",
|
|
@@ -6,7 +6,9 @@ import os
|
|
|
6
6
|
import subprocess
|
|
7
7
|
import sys
|
|
8
8
|
import tempfile
|
|
9
|
+
import time
|
|
9
10
|
import unittest
|
|
11
|
+
from datetime import datetime, timedelta, timezone
|
|
10
12
|
from concurrent.futures import ThreadPoolExecutor
|
|
11
13
|
from pathlib import Path
|
|
12
14
|
|
|
@@ -177,8 +179,17 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
177
179
|
)
|
|
178
180
|
|
|
179
181
|
def approve_task(self, repo: Path, task_id: str) -> str:
|
|
180
|
-
|
|
181
|
-
|
|
182
|
+
issued = json.loads(
|
|
183
|
+
self.ap(
|
|
184
|
+
repo,
|
|
185
|
+
"review-assignment",
|
|
186
|
+
task_id,
|
|
187
|
+
"--reviewer",
|
|
188
|
+
"test-reviewer",
|
|
189
|
+
"--json",
|
|
190
|
+
).stdout
|
|
191
|
+
)
|
|
192
|
+
fingerprint = issued["assignment"]["diff_fingerprint"]
|
|
182
193
|
self.ap(
|
|
183
194
|
repo,
|
|
184
195
|
"task-review",
|
|
@@ -386,6 +397,11 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
386
397
|
self.assertIn("START-1", rendered_status)
|
|
387
398
|
self.assertIn("codex/START-1", rendered_status)
|
|
388
399
|
self.assertIn(str(worktree), rendered_status)
|
|
400
|
+
status_payload = json.loads(
|
|
401
|
+
self.ap(repo, "task-status", "START-1", "--json").stdout
|
|
402
|
+
)["tasks"][0]
|
|
403
|
+
self.assertFalse(status_payload["has_task_commits"])
|
|
404
|
+
self.assertFalse(status_payload["merged_into_target"])
|
|
389
405
|
|
|
390
406
|
serialized_payloads = [json.dumps(item, sort_keys=True) for item in self.manifest_payloads(repo)]
|
|
391
407
|
self.assertTrue(
|
|
@@ -433,6 +449,8 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
433
449
|
self.assert_local_branch(repo, "codex/DIRECT-1", False)
|
|
434
450
|
status = json.loads(self.ap(repo, "task-status", "DIRECT-1", "--json").stdout)["tasks"][0]
|
|
435
451
|
self.assertEqual("direct", status["execution_mode"])
|
|
452
|
+
self.assertFalse(status["has_task_commits"])
|
|
453
|
+
self.assertFalse(status["merged_into_target"])
|
|
436
454
|
self.assertFalse((repo / "docs" / "tasks" / "active" / "DIRECT-1.md").exists())
|
|
437
455
|
|
|
438
456
|
(repo / "shared.txt").write_text("direct\n", encoding="utf-8")
|
|
@@ -852,6 +870,326 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
852
870
|
self.assertNotEqual(0, rejected.returncode)
|
|
853
871
|
self.assertIn("writer lease holder", rejected.stdout + rejected.stderr)
|
|
854
872
|
|
|
873
|
+
def test_review_assignment_is_deadline_bound_and_idempotent(self) -> None:
|
|
874
|
+
_, repo, _ = self.make_repo()
|
|
875
|
+
worktree = self.start_task(repo, "REVIEW-DEADLINE", "shared.txt")
|
|
876
|
+
(worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
|
|
877
|
+
|
|
878
|
+
first = json.loads(
|
|
879
|
+
self.ap(
|
|
880
|
+
worktree,
|
|
881
|
+
"review-assignment",
|
|
882
|
+
"REVIEW-DEADLINE",
|
|
883
|
+
"--reviewer",
|
|
884
|
+
"reviewer-1",
|
|
885
|
+
"--json",
|
|
886
|
+
).stdout
|
|
887
|
+
)
|
|
888
|
+
second = json.loads(
|
|
889
|
+
self.ap(
|
|
890
|
+
worktree,
|
|
891
|
+
"review-assignment",
|
|
892
|
+
"REVIEW-DEADLINE",
|
|
893
|
+
"--reviewer",
|
|
894
|
+
"reviewer-1",
|
|
895
|
+
"--json",
|
|
896
|
+
).stdout
|
|
897
|
+
)
|
|
898
|
+
self.assertEqual(first, second)
|
|
899
|
+
assignment = first["assignment"]
|
|
900
|
+
self.assertEqual("focused", assignment["review_depth"])
|
|
901
|
+
self.assertEqual(90, assignment["timeout_seconds"])
|
|
902
|
+
self.assertEqual(1, assignment["scope_revision"])
|
|
903
|
+
self.assertTrue(Path(first["assignment_path"]).is_file())
|
|
904
|
+
issued = datetime.fromisoformat(assignment["issued_at"])
|
|
905
|
+
deadline = datetime.fromisoformat(assignment["deadline_at"])
|
|
906
|
+
self.assertEqual(90, int((deadline - issued).total_seconds()))
|
|
907
|
+
|
|
908
|
+
def test_review_run_supervises_separate_process_and_records_result_once(self) -> None:
|
|
909
|
+
root, repo, _ = self.make_repo()
|
|
910
|
+
worktree = self.start_task(repo, "REVIEW-RUN", "shared.txt")
|
|
911
|
+
(worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
|
|
912
|
+
fake_reviewer = root / "fake-reviewer.py"
|
|
913
|
+
fake_reviewer.write_text(
|
|
914
|
+
"import json, os, pathlib, sys\n"
|
|
915
|
+
"if os.environ.get('CODEX_THREAD_ID'):\n"
|
|
916
|
+
" raise SystemExit(9)\n"
|
|
917
|
+
"assignment_path = pathlib.Path(os.environ['AUTOCODING_REVIEW_ASSIGNMENT'])\n"
|
|
918
|
+
"assignment = json.loads(assignment_path.read_text(encoding='utf-8'))\n"
|
|
919
|
+
"if int(os.environ['AUTOCODING_REVIEW_TIMEOUT_SECONDS']) not in (90, 300):\n"
|
|
920
|
+
" raise SystemExit(10)\n"
|
|
921
|
+
"print(json.dumps({'verdict': 'approved', 'summary': 'runtime reviewed', "
|
|
922
|
+
"'evidence': ['assignment=' + assignment['task_id']]}))\n",
|
|
923
|
+
encoding="utf-8",
|
|
924
|
+
)
|
|
925
|
+
runner = json.dumps([sys.executable, str(fake_reviewer)])
|
|
926
|
+
completed = self.ap(
|
|
927
|
+
worktree,
|
|
928
|
+
"review-run",
|
|
929
|
+
"REVIEW-RUN",
|
|
930
|
+
"--reviewer",
|
|
931
|
+
"reviewer-runtime",
|
|
932
|
+
"--runner-command-json",
|
|
933
|
+
runner,
|
|
934
|
+
"--json",
|
|
935
|
+
)
|
|
936
|
+
result = json.loads(completed.stdout)
|
|
937
|
+
self.assertEqual("approved", result["verdict"])
|
|
938
|
+
self.assertEqual("runtime reviewed", result["summary"])
|
|
939
|
+
|
|
940
|
+
status = json.loads(
|
|
941
|
+
self.ap(worktree, "task-status", "REVIEW-RUN", "--json").stdout
|
|
942
|
+
)["tasks"][0]
|
|
943
|
+
review = status["review"]
|
|
944
|
+
self.assertEqual("approved", review["verdict"])
|
|
945
|
+
self.assertEqual("completed", review["runtime_state"])
|
|
946
|
+
self.assertEqual("reviewer-runtime", review["reviewer"])
|
|
947
|
+
self.assertEqual(0, review["runtime_exit_code"])
|
|
948
|
+
result_path = Path(review["runtime_result_path"])
|
|
949
|
+
receipt_path = Path(review["runtime_receipt_path"])
|
|
950
|
+
self.assertEqual(0o600, result_path.stat().st_mode & 0o777)
|
|
951
|
+
self.assertEqual(0o600, receipt_path.stat().st_mode & 0o777)
|
|
952
|
+
receipt = json.loads(receipt_path.read_text())
|
|
953
|
+
self.assertEqual("completed", receipt["status"])
|
|
954
|
+
self.assertRegex(receipt["result_sha256"], r"^[0-9a-f]{64}$")
|
|
955
|
+
|
|
956
|
+
repeated = self.ap(
|
|
957
|
+
worktree,
|
|
958
|
+
"review-run",
|
|
959
|
+
"REVIEW-RUN",
|
|
960
|
+
"--reviewer",
|
|
961
|
+
"reviewer-runtime",
|
|
962
|
+
"--runner-command-json",
|
|
963
|
+
runner,
|
|
964
|
+
check=False,
|
|
965
|
+
)
|
|
966
|
+
self.assertNotEqual(0, repeated.returncode)
|
|
967
|
+
self.assertIn("already complete", repeated.stdout + repeated.stderr)
|
|
968
|
+
|
|
969
|
+
tampered_payload = json.loads(result_path.read_text())
|
|
970
|
+
tampered_payload["summary"] = "tampered after review"
|
|
971
|
+
result_path.write_text(json.dumps(tampered_payload) + "\n", encoding="utf-8")
|
|
972
|
+
tampered = self.ap(
|
|
973
|
+
worktree,
|
|
974
|
+
"task-review",
|
|
975
|
+
"REVIEW-RUN",
|
|
976
|
+
"--verdict",
|
|
977
|
+
"approved",
|
|
978
|
+
"--diff-fingerprint",
|
|
979
|
+
status["current_diff_fingerprint"],
|
|
980
|
+
"--reviewer",
|
|
981
|
+
"reviewer-runtime",
|
|
982
|
+
check=False,
|
|
983
|
+
)
|
|
984
|
+
self.assertNotEqual(0, tampered.returncode)
|
|
985
|
+
self.assertIn("receipt does not bind", tampered.stdout + tampered.stderr)
|
|
986
|
+
|
|
987
|
+
def test_blocked_runtime_cannot_be_reassigned_or_overwritten_as_approved(self) -> None:
|
|
988
|
+
root, repo, _ = self.make_repo()
|
|
989
|
+
worktree = self.start_task(repo, "REVIEW-BLOCKED", "shared.txt")
|
|
990
|
+
(worktree / "shared.txt").write_text("review is blocked\n", encoding="utf-8")
|
|
991
|
+
blocked_reviewer = root / "blocked-reviewer.py"
|
|
992
|
+
blocked_reviewer.write_text(
|
|
993
|
+
"import json\n"
|
|
994
|
+
"print(json.dumps({'verdict': 'blocked', 'summary': 'missing evidence'}))\n",
|
|
995
|
+
encoding="utf-8",
|
|
996
|
+
)
|
|
997
|
+
runner = json.dumps([sys.executable, str(blocked_reviewer)])
|
|
998
|
+
blocked = self.ap(
|
|
999
|
+
worktree,
|
|
1000
|
+
"review-run",
|
|
1001
|
+
"REVIEW-BLOCKED",
|
|
1002
|
+
"--reviewer",
|
|
1003
|
+
"reviewer-blocked",
|
|
1004
|
+
"--runner-command-json",
|
|
1005
|
+
runner,
|
|
1006
|
+
check=False,
|
|
1007
|
+
)
|
|
1008
|
+
self.assertNotEqual(0, blocked.returncode)
|
|
1009
|
+
self.assertIn("Reviewer returned blocked", blocked.stdout + blocked.stderr)
|
|
1010
|
+
status = json.loads(
|
|
1011
|
+
self.ap(worktree, "task-status", "REVIEW-BLOCKED", "--json").stdout
|
|
1012
|
+
)["tasks"][0]
|
|
1013
|
+
self.assertEqual("blocked", status["review"]["verdict"])
|
|
1014
|
+
self.assertEqual("blocked", status["review"]["runtime_state"])
|
|
1015
|
+
|
|
1016
|
+
reassigned = self.ap(
|
|
1017
|
+
worktree,
|
|
1018
|
+
"review-assignment",
|
|
1019
|
+
"REVIEW-BLOCKED",
|
|
1020
|
+
"--reviewer",
|
|
1021
|
+
"reviewer-blocked",
|
|
1022
|
+
check=False,
|
|
1023
|
+
)
|
|
1024
|
+
self.assertNotEqual(0, reassigned.returncode)
|
|
1025
|
+
self.assertIn("already complete or consumed", reassigned.stdout + reassigned.stderr)
|
|
1026
|
+
overwritten = self.ap(
|
|
1027
|
+
worktree,
|
|
1028
|
+
"task-review",
|
|
1029
|
+
"REVIEW-BLOCKED",
|
|
1030
|
+
"--verdict",
|
|
1031
|
+
"approved",
|
|
1032
|
+
"--diff-fingerprint",
|
|
1033
|
+
status["current_diff_fingerprint"],
|
|
1034
|
+
"--reviewer",
|
|
1035
|
+
"reviewer-blocked",
|
|
1036
|
+
check=False,
|
|
1037
|
+
)
|
|
1038
|
+
self.assertNotEqual(0, overwritten.returncode)
|
|
1039
|
+
self.assertIn("runtime state=blocked", overwritten.stdout + overwritten.stderr)
|
|
1040
|
+
|
|
1041
|
+
def test_review_run_terminates_real_process_at_original_deadline(self) -> None:
|
|
1042
|
+
root, repo, _ = self.make_repo()
|
|
1043
|
+
worktree = self.start_task(repo, "REVIEW-TIMEOUT", "shared.txt")
|
|
1044
|
+
(worktree / "shared.txt").write_text("review me slowly\n", encoding="utf-8")
|
|
1045
|
+
issued = json.loads(
|
|
1046
|
+
self.ap(
|
|
1047
|
+
worktree,
|
|
1048
|
+
"review-assignment",
|
|
1049
|
+
"REVIEW-TIMEOUT",
|
|
1050
|
+
"--reviewer",
|
|
1051
|
+
"reviewer-timeout",
|
|
1052
|
+
"--json",
|
|
1053
|
+
).stdout
|
|
1054
|
+
)
|
|
1055
|
+
deadline = datetime.now(timezone.utc).replace(microsecond=0) + timedelta(seconds=2)
|
|
1056
|
+
assignment = issued["assignment"]
|
|
1057
|
+
assignment["deadline_at"] = deadline.isoformat()
|
|
1058
|
+
assignment["issued_at"] = (deadline - timedelta(seconds=90)).isoformat()
|
|
1059
|
+
assignment_path = Path(issued["assignment_path"])
|
|
1060
|
+
assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
|
|
1061
|
+
manifest_path = self.registry_manifest_path(repo, "REVIEW-TIMEOUT")
|
|
1062
|
+
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
1063
|
+
manifest["review"]["issued_at"] = assignment["issued_at"]
|
|
1064
|
+
manifest["review"]["deadline_at"] = assignment["deadline_at"]
|
|
1065
|
+
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
1066
|
+
|
|
1067
|
+
slow_reviewer = root / "slow-reviewer.py"
|
|
1068
|
+
slow_reviewer.write_text("import time\ntime.sleep(30)\n", encoding="utf-8")
|
|
1069
|
+
started = time.monotonic()
|
|
1070
|
+
timed_out = self.ap(
|
|
1071
|
+
worktree,
|
|
1072
|
+
"review-run",
|
|
1073
|
+
"REVIEW-TIMEOUT",
|
|
1074
|
+
"--reviewer",
|
|
1075
|
+
"reviewer-timeout",
|
|
1076
|
+
"--runner-command-json",
|
|
1077
|
+
json.dumps([sys.executable, str(slow_reviewer)]),
|
|
1078
|
+
check=False,
|
|
1079
|
+
)
|
|
1080
|
+
elapsed = time.monotonic() - started
|
|
1081
|
+
self.assertNotEqual(0, timed_out.returncode)
|
|
1082
|
+
self.assertLess(elapsed, 6.0)
|
|
1083
|
+
self.assertIn("timed out and was terminated", timed_out.stdout + timed_out.stderr)
|
|
1084
|
+
status = json.loads(
|
|
1085
|
+
self.ap(worktree, "task-status", "REVIEW-TIMEOUT", "--json").stdout
|
|
1086
|
+
)["tasks"][0]
|
|
1087
|
+
self.assertEqual("blocked", status["review"]["verdict"])
|
|
1088
|
+
self.assertEqual("timed-out", status["review"]["runtime_state"])
|
|
1089
|
+
receipt = json.loads(Path(status["review"]["runtime_receipt_path"]).read_text())
|
|
1090
|
+
self.assertEqual("timed-out", receipt["status"])
|
|
1091
|
+
|
|
1092
|
+
def test_task_review_requires_assignment_and_exact_head(self) -> None:
|
|
1093
|
+
_, repo, _ = self.make_repo()
|
|
1094
|
+
worktree = self.start_task(repo, "REVIEW-HEAD", "shared.txt")
|
|
1095
|
+
(worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
|
|
1096
|
+
status = json.loads(
|
|
1097
|
+
self.ap(worktree, "task-status", "REVIEW-HEAD", "--json").stdout
|
|
1098
|
+
)["tasks"][0]
|
|
1099
|
+
missing = self.ap(
|
|
1100
|
+
worktree,
|
|
1101
|
+
"task-review",
|
|
1102
|
+
"REVIEW-HEAD",
|
|
1103
|
+
"--verdict",
|
|
1104
|
+
"approved",
|
|
1105
|
+
"--diff-fingerprint",
|
|
1106
|
+
status["current_diff_fingerprint"],
|
|
1107
|
+
"--reviewer",
|
|
1108
|
+
"reviewer-1",
|
|
1109
|
+
check=False,
|
|
1110
|
+
)
|
|
1111
|
+
self.assertNotEqual(0, missing.returncode)
|
|
1112
|
+
self.assertIn("must use review-assignment", missing.stdout + missing.stderr)
|
|
1113
|
+
|
|
1114
|
+
issued = json.loads(
|
|
1115
|
+
self.ap(
|
|
1116
|
+
worktree,
|
|
1117
|
+
"review-assignment",
|
|
1118
|
+
"REVIEW-HEAD",
|
|
1119
|
+
"--reviewer",
|
|
1120
|
+
"reviewer-1",
|
|
1121
|
+
"--json",
|
|
1122
|
+
).stdout
|
|
1123
|
+
)["assignment"]
|
|
1124
|
+
git(worktree, "add", "shared.txt")
|
|
1125
|
+
git(worktree, "commit", "-qm", "manual task commit")
|
|
1126
|
+
stale = self.ap(
|
|
1127
|
+
worktree,
|
|
1128
|
+
"task-review",
|
|
1129
|
+
"REVIEW-HEAD",
|
|
1130
|
+
"--verdict",
|
|
1131
|
+
"approved",
|
|
1132
|
+
"--diff-fingerprint",
|
|
1133
|
+
issued["diff_fingerprint"],
|
|
1134
|
+
"--reviewer",
|
|
1135
|
+
"reviewer-1",
|
|
1136
|
+
check=False,
|
|
1137
|
+
)
|
|
1138
|
+
self.assertNotEqual(0, stale.returncode)
|
|
1139
|
+
self.assertIn("HEAD is stale", stale.stdout + stale.stderr)
|
|
1140
|
+
|
|
1141
|
+
def test_expired_review_assignment_cannot_be_renewed_or_approved(self) -> None:
|
|
1142
|
+
_, repo, _ = self.make_repo()
|
|
1143
|
+
worktree = self.start_task(repo, "REVIEW-EXPIRED", "shared.txt")
|
|
1144
|
+
(worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
|
|
1145
|
+
issued = json.loads(
|
|
1146
|
+
self.ap(
|
|
1147
|
+
worktree,
|
|
1148
|
+
"review-assignment",
|
|
1149
|
+
"REVIEW-EXPIRED",
|
|
1150
|
+
"--reviewer",
|
|
1151
|
+
"reviewer-1",
|
|
1152
|
+
"--json",
|
|
1153
|
+
).stdout
|
|
1154
|
+
)
|
|
1155
|
+
assignment_path = Path(issued["assignment_path"])
|
|
1156
|
+
assignment = issued["assignment"]
|
|
1157
|
+
past_deadline = datetime.now(timezone.utc).replace(microsecond=0) - timedelta(seconds=1)
|
|
1158
|
+
assignment["deadline_at"] = past_deadline.isoformat()
|
|
1159
|
+
assignment["issued_at"] = (past_deadline - timedelta(seconds=90)).isoformat()
|
|
1160
|
+
assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
|
|
1161
|
+
|
|
1162
|
+
manifest_path = self.registry_manifest_path(repo, "REVIEW-EXPIRED")
|
|
1163
|
+
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
1164
|
+
manifest["review"]["issued_at"] = assignment["issued_at"]
|
|
1165
|
+
manifest["review"]["deadline_at"] = assignment["deadline_at"]
|
|
1166
|
+
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
1167
|
+
|
|
1168
|
+
renewed = self.ap(
|
|
1169
|
+
worktree,
|
|
1170
|
+
"review-assignment",
|
|
1171
|
+
"REVIEW-EXPIRED",
|
|
1172
|
+
"--reviewer",
|
|
1173
|
+
"reviewer-1",
|
|
1174
|
+
check=False,
|
|
1175
|
+
)
|
|
1176
|
+
self.assertNotEqual(0, renewed.returncode)
|
|
1177
|
+
self.assertIn("timed out", renewed.stdout + renewed.stderr)
|
|
1178
|
+
approved = self.ap(
|
|
1179
|
+
worktree,
|
|
1180
|
+
"task-review",
|
|
1181
|
+
"REVIEW-EXPIRED",
|
|
1182
|
+
"--verdict",
|
|
1183
|
+
"approved",
|
|
1184
|
+
"--diff-fingerprint",
|
|
1185
|
+
assignment["diff_fingerprint"],
|
|
1186
|
+
"--reviewer",
|
|
1187
|
+
"reviewer-1",
|
|
1188
|
+
check=False,
|
|
1189
|
+
)
|
|
1190
|
+
self.assertNotEqual(0, approved.returncode)
|
|
1191
|
+
self.assertIn("deadline expired", approved.stdout + approved.stderr)
|
|
1192
|
+
|
|
855
1193
|
def test_schema_one_task_status_fails_closed_with_migration_recovery(self) -> None:
|
|
856
1194
|
_, repo, _ = self.make_repo()
|
|
857
1195
|
self.start_task(repo, "LEGACY-SCHEMA")
|