@elvis1513/auto-coding-skill 4.2.7 → 4.3.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.
@@ -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 (90, 300):\n"
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():
@@ -794,7 +817,7 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
794
817
  _, repo, _ = self.make_repo("adaptive", require_review=False)
795
818
  engineering = repo / "docs" / "ENGINEERING.md"
796
819
  text = engineering.read_text(encoding="utf-8")
797
- engineering.write_text(text.replace("front-pass", "", 1), encoding="utf-8")
820
+ engineering.write_text(text.replace("front-pass", "CHANGE_ME", 1), encoding="utf-8")
798
821
  git(repo, "add", "docs/ENGINEERING.md")
799
822
  git(repo, "commit", "-qm", "invalidate access for preflight test")
800
823
  git(repo, "push", "-q", "origin", "dev")
@@ -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(90, assignment["timeout_seconds"])
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(90, int((deadline - issued).total_seconds()))
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("receipt does not bind", tampered.stdout + tampered.stderr)
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 test_review_run_terminates_real_process_at_original_deadline(self) -> None:
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
- deadline = datetime.now(timezone.utc).replace(microsecond=0) + timedelta(seconds=2)
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
- timed_out = self.ap(
1327
- worktree,
1328
- "review-run",
1329
- "REVIEW-TIMEOUT",
1330
- "--reviewer",
1331
- "reviewer-timeout",
1332
- "--runner-command-json",
1333
- json.dumps([sys.executable, str(slow_reviewer)]),
1334
- check=False,
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("timed out and was terminated", timed_out.stdout + timed_out.stderr)
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("timed-out", status["review"]["runtime_state"])
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("timed-out", receipt["status"])
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=90)).isoformat()
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")