@elvis1513/auto-coding-skill 4.2.7 → 4.2.8
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 +39 -9
- package/cli/assets/agents/reviewer.toml +2 -2
- package/cli/assets/managed-install.json +1 -1
- package/cli/assets/skill/SKILL.md +6 -7
- package/cli/assets/skill/data/policies/workflow-migrations-v1.json +2 -2
- package/cli/assets/skill/data/templates/ENGINEERING.md +2 -2
- package/cli/assets/skill/data/templates/bridges/AGENTS.md +13 -16
- package/cli/assets/skill/scripts/ap.py +1274 -91
- package/cli/tests/ap_concurrency_test.py +321 -33
- package/cli/tests/ap_profiles_test.py +326 -36
- package/cli/tests/index.test.js +23 -22
- package/package.json +1 -1
|
@@ -30,6 +30,7 @@ def command(
|
|
|
30
30
|
) -> subprocess.CompletedProcess[str]:
|
|
31
31
|
env = os.environ.copy()
|
|
32
32
|
env.setdefault("CODEX_THREAD_ID", _TEST_OWNER)
|
|
33
|
+
env.setdefault("AUTOCODING_TEST_RUNNER_OVERRIDE", "1")
|
|
33
34
|
result = subprocess.run(
|
|
34
35
|
list(args),
|
|
35
36
|
cwd=cwd,
|
|
@@ -239,7 +240,7 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
239
240
|
" raise SystemExit(13)\n"
|
|
240
241
|
"if os.environ.get('AUTOCODING_REVIEW_DIFF_ARTIFACT_SHA256') != actual:\n"
|
|
241
242
|
" raise SystemExit(14)\n"
|
|
242
|
-
"if int(os.environ['AUTOCODING_REVIEW_TIMEOUT_SECONDS']) not in (
|
|
243
|
+
"if int(os.environ['AUTOCODING_REVIEW_TIMEOUT_SECONDS']) not in (150, 360):\n"
|
|
243
244
|
" raise SystemExit(15)\n"
|
|
244
245
|
"for token in sys.argv[2:]:\n"
|
|
245
246
|
" if token.encode('utf-8') not in payload:\n"
|
|
@@ -398,6 +399,28 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
398
399
|
common_dir = (repo / common_dir).resolve()
|
|
399
400
|
return common_dir / "auto-coding-skill" / "tasks" / f"{task_id}.json"
|
|
400
401
|
|
|
402
|
+
def shorten_review_deadline(
|
|
403
|
+
self,
|
|
404
|
+
repo: Path,
|
|
405
|
+
task_id: str,
|
|
406
|
+
issued: dict,
|
|
407
|
+
seconds: int = 2,
|
|
408
|
+
) -> None:
|
|
409
|
+
deadline = datetime.now(timezone.utc).replace(microsecond=0) + timedelta(seconds=seconds)
|
|
410
|
+
assignment = issued["assignment"]
|
|
411
|
+
assignment["deadline_at"] = deadline.isoformat()
|
|
412
|
+
assignment["issued_at"] = (deadline - timedelta(seconds=150)).isoformat()
|
|
413
|
+
assignment_path = Path(issued["assignment_path"])
|
|
414
|
+
assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
|
|
415
|
+
manifest_path = self.registry_manifest_path(repo, task_id)
|
|
416
|
+
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
417
|
+
manifest["review"]["issued_at"] = assignment["issued_at"]
|
|
418
|
+
manifest["review"]["deadline_at"] = assignment["deadline_at"]
|
|
419
|
+
manifest["review"]["assignment_sha256"] = hashlib.sha256(
|
|
420
|
+
assignment_path.read_bytes()
|
|
421
|
+
).hexdigest()
|
|
422
|
+
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
423
|
+
|
|
401
424
|
def install_hook(self, repo: Path, name: str, body: str) -> Path:
|
|
402
425
|
common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
|
|
403
426
|
if not common_dir.is_absolute():
|
|
@@ -960,7 +983,7 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
960
983
|
self.assertEqual(first, second)
|
|
961
984
|
assignment = first["assignment"]
|
|
962
985
|
self.assertEqual("focused", assignment["review_depth"])
|
|
963
|
-
self.assertEqual(
|
|
986
|
+
self.assertEqual(150, assignment["timeout_seconds"])
|
|
964
987
|
self.assertEqual(1, assignment["scope_revision"])
|
|
965
988
|
self.assertTrue(Path(first["assignment_path"]).is_file())
|
|
966
989
|
assignment_path = Path(first["assignment_path"])
|
|
@@ -981,7 +1004,7 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
981
1004
|
self.assertEqual(artifact, emitted.stdout.encode("utf-8"))
|
|
982
1005
|
issued = datetime.fromisoformat(assignment["issued_at"])
|
|
983
1006
|
deadline = datetime.fromisoformat(assignment["deadline_at"])
|
|
984
|
-
self.assertEqual(
|
|
1007
|
+
self.assertEqual(150, int((deadline - issued).total_seconds()))
|
|
985
1008
|
|
|
986
1009
|
artifact_path.write_bytes(artifact + b"tampered\n")
|
|
987
1010
|
tampered = self.ap(
|
|
@@ -1235,7 +1258,153 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
1235
1258
|
check=False,
|
|
1236
1259
|
)
|
|
1237
1260
|
self.assertNotEqual(0, tampered.returncode)
|
|
1238
|
-
self.assertIn("
|
|
1261
|
+
self.assertIn("result changed", tampered.stdout + tampered.stderr)
|
|
1262
|
+
|
|
1263
|
+
def test_review_run_retries_clean_exit_without_event_and_rejects_approved_file(self) -> None:
|
|
1264
|
+
root, repo, _ = self.make_repo()
|
|
1265
|
+
worktree = self.start_task(repo, "REVIEW-NO-EVENT", "shared.txt")
|
|
1266
|
+
(worktree / "shared.txt").write_text("review without event\n", encoding="utf-8")
|
|
1267
|
+
counter = root / "attempt-count.txt"
|
|
1268
|
+
runner_path = root / "no-event-reviewer.py"
|
|
1269
|
+
runner_path.write_text(
|
|
1270
|
+
"import json, os\n"
|
|
1271
|
+
"from pathlib import Path\n"
|
|
1272
|
+
f"counter = Path({str(counter)!r})\n"
|
|
1273
|
+
"counter.write_text(str(int(counter.read_text() or '0') + 1) if counter.exists() else '1')\n"
|
|
1274
|
+
"Path(os.environ['AUTOCODING_REVIEW_RESULT']).write_text(json.dumps({'verdict': 'approved'}) + '\\n')\n",
|
|
1275
|
+
encoding="utf-8",
|
|
1276
|
+
)
|
|
1277
|
+
rejected = self.ap(
|
|
1278
|
+
worktree,
|
|
1279
|
+
"review-run",
|
|
1280
|
+
"REVIEW-NO-EVENT",
|
|
1281
|
+
"--reviewer",
|
|
1282
|
+
"reviewer-no-event",
|
|
1283
|
+
"--runner-command-json",
|
|
1284
|
+
json.dumps([sys.executable, str(runner_path)]),
|
|
1285
|
+
check=False,
|
|
1286
|
+
)
|
|
1287
|
+
self.assertNotEqual(0, rejected.returncode)
|
|
1288
|
+
self.assertIn("runtime-unavailable", rejected.stdout + rejected.stderr)
|
|
1289
|
+
self.assertEqual("2", counter.read_text())
|
|
1290
|
+
status = json.loads(
|
|
1291
|
+
self.ap(worktree, "task-status", "REVIEW-NO-EVENT", "--json").stdout
|
|
1292
|
+
)["tasks"][0]
|
|
1293
|
+
self.assertEqual("runtime-unavailable", status["review"]["runtime_state"])
|
|
1294
|
+
self.assertEqual("blocked", status["review"]["verdict"])
|
|
1295
|
+
|
|
1296
|
+
def test_substantive_result_written_before_timeout_cannot_be_bypassed(self) -> None:
|
|
1297
|
+
root, repo, _ = self.make_repo()
|
|
1298
|
+
worktree = self.start_task(repo, "REVIEW-SUBSTANTIVE", "shared.txt")
|
|
1299
|
+
(worktree / "shared.txt").write_text("substantive finding\n", encoding="utf-8")
|
|
1300
|
+
issued = json.loads(
|
|
1301
|
+
self.ap(
|
|
1302
|
+
worktree,
|
|
1303
|
+
"review-assignment",
|
|
1304
|
+
"REVIEW-SUBSTANTIVE",
|
|
1305
|
+
"--reviewer",
|
|
1306
|
+
"reviewer-substantive",
|
|
1307
|
+
"--json",
|
|
1308
|
+
).stdout
|
|
1309
|
+
)
|
|
1310
|
+
self.shorten_review_deadline(repo, "REVIEW-SUBSTANTIVE", issued)
|
|
1311
|
+
runner_path = root / "substantive-reviewer.py"
|
|
1312
|
+
runner_path.write_text(
|
|
1313
|
+
"import json, os, time\n"
|
|
1314
|
+
"from pathlib import Path\n"
|
|
1315
|
+
"result = Path(os.environ['AUTOCODING_REVIEW_RESULT'])\n"
|
|
1316
|
+
"result.write_text(json.dumps({'verdict': 'changes-requested', 'summary': 'real defect'}) + '\\n')\n"
|
|
1317
|
+
"result.chmod(0o600)\n"
|
|
1318
|
+
"print(json.dumps({'type': 'turn.started'}), flush=True)\n"
|
|
1319
|
+
"time.sleep(30)\n",
|
|
1320
|
+
encoding="utf-8",
|
|
1321
|
+
)
|
|
1322
|
+
timed_out = self.ap(
|
|
1323
|
+
worktree,
|
|
1324
|
+
"review-run",
|
|
1325
|
+
"REVIEW-SUBSTANTIVE",
|
|
1326
|
+
"--reviewer",
|
|
1327
|
+
"reviewer-substantive",
|
|
1328
|
+
"--runner-command-json",
|
|
1329
|
+
json.dumps([sys.executable, str(runner_path)]),
|
|
1330
|
+
check=False,
|
|
1331
|
+
)
|
|
1332
|
+
self.assertNotEqual(0, timed_out.returncode)
|
|
1333
|
+
self.assertIn("cannot be bypassed", timed_out.stdout + timed_out.stderr)
|
|
1334
|
+
status = json.loads(
|
|
1335
|
+
self.ap(worktree, "task-status", "REVIEW-SUBSTANTIVE", "--json").stdout
|
|
1336
|
+
)["tasks"][0]
|
|
1337
|
+
review = status["review"]
|
|
1338
|
+
self.assertEqual("changes-requested", review["verdict"])
|
|
1339
|
+
self.assertEqual("blocked", review["runtime_state"])
|
|
1340
|
+
receipt = json.loads(Path(review["runtime_receipt_path"]).read_text())
|
|
1341
|
+
self.assertEqual("blocked", receipt["status"])
|
|
1342
|
+
self.assertEqual("changes-requested", receipt["verdict"])
|
|
1343
|
+
self.assertEqual(1, len(receipt["attempts"]))
|
|
1344
|
+
bypass = self.ap(
|
|
1345
|
+
worktree,
|
|
1346
|
+
"review-runtime-override",
|
|
1347
|
+
"REVIEW-SUBSTANTIVE",
|
|
1348
|
+
"--diff-fingerprint",
|
|
1349
|
+
status["current_diff_fingerprint"],
|
|
1350
|
+
"--authorized-by",
|
|
1351
|
+
"product-owner",
|
|
1352
|
+
"--authorization-ref",
|
|
1353
|
+
"conversation-substantive",
|
|
1354
|
+
"--reason",
|
|
1355
|
+
"A substantive Reviewer result must remain blocking.",
|
|
1356
|
+
"--evidence",
|
|
1357
|
+
"reviewer returned changes requested",
|
|
1358
|
+
"--confirm-runtime-bypass",
|
|
1359
|
+
check=False,
|
|
1360
|
+
)
|
|
1361
|
+
self.assertNotEqual(0, bypass.returncode)
|
|
1362
|
+
self.assertIn("allowed only after", bypass.stdout + bypass.stderr)
|
|
1363
|
+
|
|
1364
|
+
def test_substantive_agent_message_before_timeout_cannot_be_bypassed(self) -> None:
|
|
1365
|
+
root, repo, _ = self.make_repo()
|
|
1366
|
+
worktree = self.start_task(repo, "REVIEW-EVENT-FINDING", "shared.txt")
|
|
1367
|
+
(worktree / "shared.txt").write_text("event finding\n", encoding="utf-8")
|
|
1368
|
+
issued = json.loads(
|
|
1369
|
+
self.ap(
|
|
1370
|
+
worktree,
|
|
1371
|
+
"review-assignment",
|
|
1372
|
+
"REVIEW-EVENT-FINDING",
|
|
1373
|
+
"--reviewer",
|
|
1374
|
+
"reviewer-event-finding",
|
|
1375
|
+
"--json",
|
|
1376
|
+
).stdout
|
|
1377
|
+
)
|
|
1378
|
+
self.shorten_review_deadline(repo, "REVIEW-EVENT-FINDING", issued)
|
|
1379
|
+
runner_path = root / "event-finding-reviewer.py"
|
|
1380
|
+
runner_path.write_text(
|
|
1381
|
+
"import json, sys, time\n"
|
|
1382
|
+
"result = json.dumps({'verdict': 'blocked', 'summary': 'event-only defect'})\n"
|
|
1383
|
+
"print(json.dumps({'type': 'turn.started'}), flush=True)\n"
|
|
1384
|
+
"sys.stdout.write(json.dumps({'type': 'item.completed', 'item': {'type': 'agent_message', 'text': result}}))\n"
|
|
1385
|
+
"sys.stdout.flush()\n"
|
|
1386
|
+
"time.sleep(30)\n",
|
|
1387
|
+
encoding="utf-8",
|
|
1388
|
+
)
|
|
1389
|
+
timed_out = self.ap(
|
|
1390
|
+
worktree,
|
|
1391
|
+
"review-run",
|
|
1392
|
+
"REVIEW-EVENT-FINDING",
|
|
1393
|
+
"--reviewer",
|
|
1394
|
+
"reviewer-event-finding",
|
|
1395
|
+
"--runner-command-json",
|
|
1396
|
+
json.dumps([sys.executable, str(runner_path)]),
|
|
1397
|
+
check=False,
|
|
1398
|
+
)
|
|
1399
|
+
self.assertNotEqual(0, timed_out.returncode)
|
|
1400
|
+
self.assertIn("cannot be bypassed", timed_out.stdout + timed_out.stderr)
|
|
1401
|
+
status = json.loads(
|
|
1402
|
+
self.ap(worktree, "task-status", "REVIEW-EVENT-FINDING", "--json").stdout
|
|
1403
|
+
)["tasks"][0]
|
|
1404
|
+
self.assertEqual("blocked", status["review"]["verdict"])
|
|
1405
|
+
self.assertEqual("blocked", status["review"]["runtime_state"])
|
|
1406
|
+
result = json.loads(Path(status["review"]["runtime_result_path"]).read_text())
|
|
1407
|
+
self.assertEqual("event-only defect", result["summary"])
|
|
1239
1408
|
|
|
1240
1409
|
def test_blocked_runtime_cannot_be_reassigned_or_overwritten_as_approved(self) -> None:
|
|
1241
1410
|
root, repo, _ = self.make_repo()
|
|
@@ -1290,8 +1459,27 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
1290
1459
|
)
|
|
1291
1460
|
self.assertNotEqual(0, overwritten.returncode)
|
|
1292
1461
|
self.assertIn("runtime state=blocked", overwritten.stdout + overwritten.stderr)
|
|
1462
|
+
bypass = self.ap(
|
|
1463
|
+
worktree,
|
|
1464
|
+
"review-runtime-override",
|
|
1465
|
+
"REVIEW-BLOCKED",
|
|
1466
|
+
"--diff-fingerprint",
|
|
1467
|
+
status["current_diff_fingerprint"],
|
|
1468
|
+
"--authorized-by",
|
|
1469
|
+
"product-owner",
|
|
1470
|
+
"--authorization-ref",
|
|
1471
|
+
"conversation-blocked",
|
|
1472
|
+
"--reason",
|
|
1473
|
+
"User cannot override a substantive Reviewer blocked verdict.",
|
|
1474
|
+
"--evidence",
|
|
1475
|
+
"reviewer returned blocked",
|
|
1476
|
+
"--confirm-runtime-bypass",
|
|
1477
|
+
check=False,
|
|
1478
|
+
)
|
|
1479
|
+
self.assertNotEqual(0, bypass.returncode)
|
|
1480
|
+
self.assertIn("allowed only after", bypass.stdout + bypass.stderr)
|
|
1293
1481
|
|
|
1294
|
-
def
|
|
1482
|
+
def test_review_run_retries_runtime_unavailable_and_allows_bound_user_override(self) -> None:
|
|
1295
1483
|
root, repo, _ = self.make_repo()
|
|
1296
1484
|
worktree = self.start_task(repo, "REVIEW-TIMEOUT", "shared.txt")
|
|
1297
1485
|
(worktree / "shared.txt").write_text("review me slowly\n", encoding="utf-8")
|
|
@@ -1305,45 +1493,145 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
1305
1493
|
"--json",
|
|
1306
1494
|
).stdout
|
|
1307
1495
|
)
|
|
1308
|
-
|
|
1309
|
-
assignment = issued["assignment"]
|
|
1310
|
-
assignment["deadline_at"] = deadline.isoformat()
|
|
1311
|
-
assignment["issued_at"] = (deadline - timedelta(seconds=90)).isoformat()
|
|
1312
|
-
assignment_path = Path(issued["assignment_path"])
|
|
1313
|
-
assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
|
|
1314
|
-
manifest_path = self.registry_manifest_path(repo, "REVIEW-TIMEOUT")
|
|
1315
|
-
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
1316
|
-
manifest["review"]["issued_at"] = assignment["issued_at"]
|
|
1317
|
-
manifest["review"]["deadline_at"] = assignment["deadline_at"]
|
|
1318
|
-
manifest["review"]["assignment_sha256"] = hashlib.sha256(
|
|
1319
|
-
assignment_path.read_bytes()
|
|
1320
|
-
).hexdigest()
|
|
1321
|
-
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
1496
|
+
self.shorten_review_deadline(repo, "REVIEW-TIMEOUT", issued, seconds=5)
|
|
1322
1497
|
|
|
1323
1498
|
slow_reviewer = root / "slow-reviewer.py"
|
|
1324
1499
|
slow_reviewer.write_text("import time\ntime.sleep(30)\n", encoding="utf-8")
|
|
1325
1500
|
started = time.monotonic()
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
|
|
1501
|
+
previous_startup_timeout = os.environ.get("AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS")
|
|
1502
|
+
os.environ["AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS"] = "0.1"
|
|
1503
|
+
try:
|
|
1504
|
+
timed_out = self.ap(
|
|
1505
|
+
worktree,
|
|
1506
|
+
"review-run",
|
|
1507
|
+
"REVIEW-TIMEOUT",
|
|
1508
|
+
"--reviewer",
|
|
1509
|
+
"reviewer-timeout",
|
|
1510
|
+
"--runner-command-json",
|
|
1511
|
+
json.dumps([sys.executable, str(slow_reviewer)]),
|
|
1512
|
+
check=False,
|
|
1513
|
+
)
|
|
1514
|
+
finally:
|
|
1515
|
+
if previous_startup_timeout is None:
|
|
1516
|
+
os.environ.pop("AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS", None)
|
|
1517
|
+
else:
|
|
1518
|
+
os.environ["AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS"] = previous_startup_timeout
|
|
1336
1519
|
elapsed = time.monotonic() - started
|
|
1337
1520
|
self.assertNotEqual(0, timed_out.returncode)
|
|
1338
1521
|
self.assertLess(elapsed, 6.0)
|
|
1339
|
-
self.assertIn("
|
|
1522
|
+
self.assertIn("runtime-unavailable", timed_out.stdout + timed_out.stderr)
|
|
1340
1523
|
status = json.loads(
|
|
1341
1524
|
self.ap(worktree, "task-status", "REVIEW-TIMEOUT", "--json").stdout
|
|
1342
1525
|
)["tasks"][0]
|
|
1343
1526
|
self.assertEqual("blocked", status["review"]["verdict"])
|
|
1344
|
-
self.assertEqual("
|
|
1527
|
+
self.assertEqual("runtime-unavailable", status["review"]["runtime_state"])
|
|
1345
1528
|
receipt = json.loads(Path(status["review"]["runtime_receipt_path"]).read_text())
|
|
1346
|
-
self.assertEqual(
|
|
1529
|
+
self.assertEqual(2, receipt["schema"])
|
|
1530
|
+
self.assertEqual("runtime-unavailable", receipt["status"])
|
|
1531
|
+
self.assertEqual(2, len(receipt["attempts"]))
|
|
1532
|
+
self.assertRegex(receipt["event_log_sha256"], r"^[0-9a-f]{64}$")
|
|
1533
|
+
|
|
1534
|
+
receipt_path = Path(status["review"]["runtime_receipt_path"])
|
|
1535
|
+
original_receipt = receipt_path.read_bytes()
|
|
1536
|
+
tampered_receipt = json.loads(original_receipt)
|
|
1537
|
+
tampered_receipt["failure_kind"] = "tampered-before-override"
|
|
1538
|
+
receipt_path.write_text(json.dumps(tampered_receipt) + "\n", encoding="utf-8")
|
|
1539
|
+
rejected_receipt = self.ap(
|
|
1540
|
+
worktree,
|
|
1541
|
+
"review-runtime-override",
|
|
1542
|
+
"REVIEW-TIMEOUT",
|
|
1543
|
+
"--diff-fingerprint",
|
|
1544
|
+
status["current_diff_fingerprint"],
|
|
1545
|
+
"--authorized-by",
|
|
1546
|
+
"product-owner",
|
|
1547
|
+
"--authorization-ref",
|
|
1548
|
+
"conversation-pre-tamper",
|
|
1549
|
+
"--reason",
|
|
1550
|
+
"Tampered pre-override evidence must be rejected.",
|
|
1551
|
+
"--evidence",
|
|
1552
|
+
"targeted tests passed",
|
|
1553
|
+
"--confirm-runtime-bypass",
|
|
1554
|
+
check=False,
|
|
1555
|
+
)
|
|
1556
|
+
self.assertNotEqual(0, rejected_receipt.returncode)
|
|
1557
|
+
self.assertIn("changed after failure finalization", rejected_receipt.stdout + rejected_receipt.stderr)
|
|
1558
|
+
receipt_path.write_bytes(original_receipt)
|
|
1559
|
+
|
|
1560
|
+
event_log_path = Path(status["review"]["runtime_event_log_path"])
|
|
1561
|
+
original_event_log = event_log_path.read_bytes()
|
|
1562
|
+
event_log_path.write_bytes(original_event_log + b'{"event_type":"tampered"}\n')
|
|
1563
|
+
rejected_event = self.ap(
|
|
1564
|
+
worktree,
|
|
1565
|
+
"review-runtime-override",
|
|
1566
|
+
"REVIEW-TIMEOUT",
|
|
1567
|
+
"--diff-fingerprint",
|
|
1568
|
+
status["current_diff_fingerprint"],
|
|
1569
|
+
"--authorized-by",
|
|
1570
|
+
"product-owner",
|
|
1571
|
+
"--authorization-ref",
|
|
1572
|
+
"conversation-event-tamper",
|
|
1573
|
+
"--reason",
|
|
1574
|
+
"Tampered event evidence must be rejected before override.",
|
|
1575
|
+
"--evidence",
|
|
1576
|
+
"targeted tests passed",
|
|
1577
|
+
"--confirm-runtime-bypass",
|
|
1578
|
+
check=False,
|
|
1579
|
+
)
|
|
1580
|
+
self.assertNotEqual(0, rejected_event.returncode)
|
|
1581
|
+
self.assertIn("event log changed", rejected_event.stdout + rejected_event.stderr)
|
|
1582
|
+
event_log_path.write_bytes(original_event_log)
|
|
1583
|
+
|
|
1584
|
+
override = json.loads(
|
|
1585
|
+
self.ap(
|
|
1586
|
+
worktree,
|
|
1587
|
+
"review-runtime-override",
|
|
1588
|
+
"REVIEW-TIMEOUT",
|
|
1589
|
+
"--diff-fingerprint",
|
|
1590
|
+
status["current_diff_fingerprint"],
|
|
1591
|
+
"--authorized-by",
|
|
1592
|
+
"product-owner",
|
|
1593
|
+
"--authorization-ref",
|
|
1594
|
+
"conversation-2026-07-17",
|
|
1595
|
+
"--reason",
|
|
1596
|
+
"User accepted the exhausted Reviewer runtime failure.",
|
|
1597
|
+
"--evidence",
|
|
1598
|
+
"targeted tests passed",
|
|
1599
|
+
"--confirm-runtime-bypass",
|
|
1600
|
+
"--json",
|
|
1601
|
+
).stdout
|
|
1602
|
+
)
|
|
1603
|
+
self.assertEqual("runtime-bypassed", override["verdict"])
|
|
1604
|
+
bypassed_status = json.loads(
|
|
1605
|
+
self.ap(worktree, "task-status", "REVIEW-TIMEOUT", "--json").stdout
|
|
1606
|
+
)["tasks"][0]
|
|
1607
|
+
self.assertEqual("runtime-bypassed", bypassed_status["review"]["verdict"])
|
|
1608
|
+
self.assertEqual("runtime-bypassed", bypassed_status["review"]["runtime_state"])
|
|
1609
|
+
|
|
1610
|
+
receipt_path = Path(bypassed_status["review"]["runtime_receipt_path"])
|
|
1611
|
+
original_receipt = receipt_path.read_bytes()
|
|
1612
|
+
tampered_receipt = json.loads(original_receipt)
|
|
1613
|
+
tampered_receipt["failure_kind"] = "tampered"
|
|
1614
|
+
receipt_path.write_text(json.dumps(tampered_receipt) + "\n", encoding="utf-8")
|
|
1615
|
+
rejected_tamper = self.ap(
|
|
1616
|
+
worktree,
|
|
1617
|
+
"commit-push",
|
|
1618
|
+
"REVIEW-TIMEOUT",
|
|
1619
|
+
"--msg",
|
|
1620
|
+
"test: reject tampered runtime bypass",
|
|
1621
|
+
check=False,
|
|
1622
|
+
)
|
|
1623
|
+
self.assertNotEqual(0, rejected_tamper.returncode)
|
|
1624
|
+
self.assertIn("receipt SHA-256", rejected_tamper.stdout + rejected_tamper.stderr)
|
|
1625
|
+
receipt_path.write_bytes(original_receipt)
|
|
1626
|
+
|
|
1627
|
+
pushed = self.ap(
|
|
1628
|
+
worktree,
|
|
1629
|
+
"commit-push",
|
|
1630
|
+
"REVIEW-TIMEOUT",
|
|
1631
|
+
"--msg",
|
|
1632
|
+
"test: allow bound runtime bypass",
|
|
1633
|
+
)
|
|
1634
|
+
self.assertIn("commit-push", pushed.stdout + pushed.stderr)
|
|
1347
1635
|
|
|
1348
1636
|
def test_task_review_requires_assignment_and_exact_head(self) -> None:
|
|
1349
1637
|
_, repo, _ = self.make_repo()
|
|
@@ -1412,7 +1700,7 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
1412
1700
|
assignment = issued["assignment"]
|
|
1413
1701
|
past_deadline = datetime.now(timezone.utc).replace(microsecond=0) - timedelta(seconds=1)
|
|
1414
1702
|
assignment["deadline_at"] = past_deadline.isoformat()
|
|
1415
|
-
assignment["issued_at"] = (past_deadline - timedelta(seconds=
|
|
1703
|
+
assignment["issued_at"] = (past_deadline - timedelta(seconds=150)).isoformat()
|
|
1416
1704
|
assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
|
|
1417
1705
|
|
|
1418
1706
|
manifest_path = self.registry_manifest_path(repo, "REVIEW-EXPIRED")
|