@elvis1513/auto-coding-skill 4.3.3 → 4.3.5
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 +52 -1
- package/cli/assets/managed-install.json +1 -1
- package/cli/assets/skill/SKILL.md +8 -0
- 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 +9 -1
- package/cli/assets/skill/scripts/ap.py +1044 -35
- package/cli/tests/ap_concurrency_test.py +335 -2
- package/cli/tests/core_shell_test.py +5 -5
- package/cli/tests/index.test.js +34 -33
- package/package.json +1 -1
|
@@ -4,6 +4,7 @@ from __future__ import annotations
|
|
|
4
4
|
import hashlib
|
|
5
5
|
import json
|
|
6
6
|
import os
|
|
7
|
+
import shutil
|
|
7
8
|
import subprocess
|
|
8
9
|
import sys
|
|
9
10
|
import tempfile
|
|
@@ -180,6 +181,52 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
180
181
|
check=check,
|
|
181
182
|
)
|
|
182
183
|
|
|
184
|
+
def ap_script(
|
|
185
|
+
self,
|
|
186
|
+
repo: Path,
|
|
187
|
+
script: Path,
|
|
188
|
+
*args: str,
|
|
189
|
+
check: bool = True,
|
|
190
|
+
) -> subprocess.CompletedProcess[str]:
|
|
191
|
+
return command(
|
|
192
|
+
repo,
|
|
193
|
+
sys.executable,
|
|
194
|
+
str(script),
|
|
195
|
+
"--repo",
|
|
196
|
+
str(repo),
|
|
197
|
+
*args,
|
|
198
|
+
check=check,
|
|
199
|
+
)
|
|
200
|
+
|
|
201
|
+
def managed_runtime(self, root: Path, version: str = "4.3.5") -> Path:
|
|
202
|
+
install_root = root / "managed-runtime"
|
|
203
|
+
skill = install_root / ".agents" / "skills" / "auto-coding-skill"
|
|
204
|
+
shutil.copytree(REPO_ROOT / "src" / "auto-coding-skill", skill)
|
|
205
|
+
script = skill / "scripts" / "ap.py"
|
|
206
|
+
relative = ".agents/skills/auto-coding-skill/scripts/ap.py"
|
|
207
|
+
manifest = {
|
|
208
|
+
"schema_version": 1,
|
|
209
|
+
"skill_version": version,
|
|
210
|
+
"manifest_path": ".agents/managed-install.json",
|
|
211
|
+
"entries": [
|
|
212
|
+
{
|
|
213
|
+
"path": relative,
|
|
214
|
+
"source": "skill/scripts/ap.py",
|
|
215
|
+
"ownership": "exact",
|
|
216
|
+
"sha256": hashlib.sha256(script.read_bytes()).hexdigest(),
|
|
217
|
+
"executable": bool(script.stat().st_mode & 0o111),
|
|
218
|
+
"scope": "shared",
|
|
219
|
+
"version": version,
|
|
220
|
+
}
|
|
221
|
+
],
|
|
222
|
+
"managed_namespaces": [],
|
|
223
|
+
"preserved": [],
|
|
224
|
+
}
|
|
225
|
+
manifest_path = install_root / ".agents" / "managed-install.json"
|
|
226
|
+
manifest_path.parent.mkdir(parents=True, exist_ok=True)
|
|
227
|
+
manifest_path.write_text(json.dumps(manifest) + "\n", encoding="utf-8")
|
|
228
|
+
return script
|
|
229
|
+
|
|
183
230
|
def approve_task(self, repo: Path, task_id: str) -> str:
|
|
184
231
|
issued = json.loads(
|
|
185
232
|
self.ap(
|
|
@@ -216,7 +263,12 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
216
263
|
self.approve_task(repo, task_id)
|
|
217
264
|
return self.ap(repo, "commit-push", task_id, "--msg", message)
|
|
218
265
|
|
|
219
|
-
def artifact_reviewer_runner(
|
|
266
|
+
def artifact_reviewer_runner(
|
|
267
|
+
self,
|
|
268
|
+
root: Path,
|
|
269
|
+
*tokens: str,
|
|
270
|
+
runtime_script: Path = AP_SCRIPT,
|
|
271
|
+
) -> str:
|
|
220
272
|
fake_reviewer = root / "fake-artifact-reviewer.py"
|
|
221
273
|
fake_reviewer.write_text(
|
|
222
274
|
"import hashlib, json, os, pathlib, subprocess, sys\n"
|
|
@@ -249,7 +301,7 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
249
301
|
"'evidence': ['diff_artifact_sha256=' + actual]}))\n",
|
|
250
302
|
encoding="utf-8",
|
|
251
303
|
)
|
|
252
|
-
return json.dumps([sys.executable, str(fake_reviewer), str(
|
|
304
|
+
return json.dumps([sys.executable, str(fake_reviewer), str(runtime_script), *tokens])
|
|
253
305
|
|
|
254
306
|
def task_worktree(self, repo: Path, task_id: str) -> Path:
|
|
255
307
|
wanted = f"refs/heads/codex/{task_id}"
|
|
@@ -1553,6 +1605,287 @@ class AutoCodingConcurrencyTests(unittest.TestCase):
|
|
|
1553
1605
|
self.assertNotEqual(0, bypass.returncode)
|
|
1554
1606
|
self.assertIn("allowed only after", bypass.stdout + bypass.stderr)
|
|
1555
1607
|
|
|
1608
|
+
def test_known_432_artifact_access_block_gets_one_immutable_managed_retry(self) -> None:
|
|
1609
|
+
root, repo, _ = self.make_repo()
|
|
1610
|
+
managed_script = self.managed_runtime(root)
|
|
1611
|
+
worktree = self.start_task(repo, "REVIEW-MANAGED-RETRY", "shared.txt")
|
|
1612
|
+
(worktree / "shared.txt").write_text("managed retry payload\n", encoding="utf-8")
|
|
1613
|
+
common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
|
|
1614
|
+
if not common_dir.is_absolute():
|
|
1615
|
+
common_dir = (repo / common_dir).resolve()
|
|
1616
|
+
state_root = common_dir / "auto-coding-skill"
|
|
1617
|
+
blocked_reviewer = root / "known-artifact-access-block.py"
|
|
1618
|
+
blocked_reviewer.write_text(
|
|
1619
|
+
"import json\n"
|
|
1620
|
+
f"state_root = {str(state_root)!r}\n"
|
|
1621
|
+
"print(json.dumps({"
|
|
1622
|
+
"'verdict': 'blocked', "
|
|
1623
|
+
"'summary': 'Review could not begin because review-artifact failed before emitting the immutable patch.', "
|
|
1624
|
+
"'evidence': ['review-artifact exited 2: Cannot protect Git-local review storage at ' + state_root + ': Operation not permitted.'], "
|
|
1625
|
+
"'risks': ['The immutable patch was not emitted or substantively reviewed.']}))\n",
|
|
1626
|
+
encoding="utf-8",
|
|
1627
|
+
)
|
|
1628
|
+
blocked = self.ap(
|
|
1629
|
+
worktree,
|
|
1630
|
+
"review-run",
|
|
1631
|
+
"REVIEW-MANAGED-RETRY",
|
|
1632
|
+
"--reviewer",
|
|
1633
|
+
"managed-retry-reviewer",
|
|
1634
|
+
"--runner-command-json",
|
|
1635
|
+
json.dumps([sys.executable, str(blocked_reviewer)]),
|
|
1636
|
+
check=False,
|
|
1637
|
+
)
|
|
1638
|
+
self.assertNotEqual(0, blocked.returncode)
|
|
1639
|
+
manifest_path = self.registry_manifest_path(repo, "REVIEW-MANAGED-RETRY")
|
|
1640
|
+
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
1641
|
+
manifest["skill_version"] = "4.3.2"
|
|
1642
|
+
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
1643
|
+
prior_review = manifest["review"]
|
|
1644
|
+
prior_paths = [
|
|
1645
|
+
Path(prior_review["assignment_path"]),
|
|
1646
|
+
Path(prior_review["diff_artifact_path"]),
|
|
1647
|
+
Path(prior_review["runtime_result_path"]),
|
|
1648
|
+
Path(prior_review["runtime_receipt_path"]),
|
|
1649
|
+
Path(prior_review["runtime_event_log_path"]),
|
|
1650
|
+
]
|
|
1651
|
+
prior_bytes = {path: path.read_bytes() for path in prior_paths}
|
|
1652
|
+
fingerprint = prior_review["diff_fingerprint"]
|
|
1653
|
+
|
|
1654
|
+
authorized = json.loads(
|
|
1655
|
+
self.ap_script(
|
|
1656
|
+
worktree,
|
|
1657
|
+
managed_script,
|
|
1658
|
+
"review-runtime-retry",
|
|
1659
|
+
"REVIEW-MANAGED-RETRY",
|
|
1660
|
+
"--diff-fingerprint",
|
|
1661
|
+
fingerprint,
|
|
1662
|
+
"--reason-code",
|
|
1663
|
+
"managed-review-artifact-access",
|
|
1664
|
+
"--confirm-managed-runtime-retry",
|
|
1665
|
+
"--json",
|
|
1666
|
+
).stdout
|
|
1667
|
+
)
|
|
1668
|
+
self.assertEqual("retry-authorized", authorized["status"])
|
|
1669
|
+
self.assertEqual("retry-v4.3.5", authorized["retry_token"])
|
|
1670
|
+
audit_path = Path(authorized["audit_path"])
|
|
1671
|
+
self.assertEqual(0o600, audit_path.stat().st_mode & 0o777)
|
|
1672
|
+
audit = json.loads(audit_path.read_text(encoding="utf-8"))
|
|
1673
|
+
self.assertEqual("4.3.2", audit["task_skill_version"])
|
|
1674
|
+
self.assertEqual(hashlib.sha256(prior_bytes[prior_paths[2]]).hexdigest(), audit["prior_result_sha256"])
|
|
1675
|
+
|
|
1676
|
+
runner = self.artifact_reviewer_runner(
|
|
1677
|
+
root,
|
|
1678
|
+
"managed retry payload",
|
|
1679
|
+
runtime_script=managed_script,
|
|
1680
|
+
)
|
|
1681
|
+
reviewed = json.loads(
|
|
1682
|
+
self.ap_script(
|
|
1683
|
+
worktree,
|
|
1684
|
+
managed_script,
|
|
1685
|
+
"review-run",
|
|
1686
|
+
"REVIEW-MANAGED-RETRY",
|
|
1687
|
+
"--reviewer",
|
|
1688
|
+
"managed-retry-reviewer",
|
|
1689
|
+
"--runner-command-json",
|
|
1690
|
+
runner,
|
|
1691
|
+
"--json",
|
|
1692
|
+
).stdout
|
|
1693
|
+
)
|
|
1694
|
+
self.assertEqual("approved", reviewed["verdict"])
|
|
1695
|
+
for path, original in prior_bytes.items():
|
|
1696
|
+
self.assertEqual(original, path.read_bytes(), str(path))
|
|
1697
|
+
status = json.loads(
|
|
1698
|
+
self.ap_script(
|
|
1699
|
+
worktree,
|
|
1700
|
+
managed_script,
|
|
1701
|
+
"task-status",
|
|
1702
|
+
"REVIEW-MANAGED-RETRY",
|
|
1703
|
+
"--json",
|
|
1704
|
+
).stdout
|
|
1705
|
+
)["tasks"][0]
|
|
1706
|
+
retry_review = status["review"]
|
|
1707
|
+
self.assertEqual("approved", retry_review["verdict"])
|
|
1708
|
+
self.assertIn(".retry-v4.3.5.result.json", retry_review["runtime_result_path"])
|
|
1709
|
+
retry_receipt = json.loads(Path(retry_review["runtime_receipt_path"]).read_text())
|
|
1710
|
+
self.assertEqual("retry-v4.3.5", retry_receipt["runtime_retry_token"])
|
|
1711
|
+
self.assertEqual(authorized["audit_sha256"], retry_receipt["runtime_retry_audit_sha256"])
|
|
1712
|
+
|
|
1713
|
+
repeated = self.ap_script(
|
|
1714
|
+
worktree,
|
|
1715
|
+
managed_script,
|
|
1716
|
+
"review-runtime-retry",
|
|
1717
|
+
"REVIEW-MANAGED-RETRY",
|
|
1718
|
+
"--diff-fingerprint",
|
|
1719
|
+
fingerprint,
|
|
1720
|
+
"--reason-code",
|
|
1721
|
+
"managed-review-artifact-access",
|
|
1722
|
+
"--confirm-managed-runtime-retry",
|
|
1723
|
+
check=False,
|
|
1724
|
+
)
|
|
1725
|
+
self.assertNotEqual(0, repeated.returncode)
|
|
1726
|
+
|
|
1727
|
+
def test_434_retry_artifact_access_block_gets_one_435_repair(self) -> None:
|
|
1728
|
+
root, repo, _ = self.make_repo()
|
|
1729
|
+
managed_434 = self.managed_runtime(root / "runtime-434", "4.3.4")
|
|
1730
|
+
managed_435 = self.managed_runtime(root / "runtime-435", "4.3.5")
|
|
1731
|
+
worktree = self.start_task(repo, "REVIEW-RETRY-REPAIR", "shared.txt")
|
|
1732
|
+
(worktree / "shared.txt").write_text("repair retry payload\n", encoding="utf-8")
|
|
1733
|
+
common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
|
|
1734
|
+
if not common_dir.is_absolute():
|
|
1735
|
+
common_dir = (repo / common_dir).resolve()
|
|
1736
|
+
state_root = common_dir / "auto-coding-skill"
|
|
1737
|
+
blocked_reviewer = root / "repair-artifact-access-block.py"
|
|
1738
|
+
blocked_reviewer.write_text(
|
|
1739
|
+
"import json\n"
|
|
1740
|
+
f"state_root = {str(state_root)!r}\n"
|
|
1741
|
+
"print(json.dumps({"
|
|
1742
|
+
"'verdict': 'blocked', "
|
|
1743
|
+
"'summary': 'Review could not begin because review-artifact failed before emitting the immutable patch.', "
|
|
1744
|
+
"'evidence': ['review-artifact exited 2: Cannot protect Git-local review storage at ' + state_root + ': Operation not permitted.'], "
|
|
1745
|
+
"'risks': ['The immutable patch was not emitted or substantively reviewed.']}))\n",
|
|
1746
|
+
encoding="utf-8",
|
|
1747
|
+
)
|
|
1748
|
+
blocked_runner = json.dumps([sys.executable, str(blocked_reviewer)])
|
|
1749
|
+
self.ap(
|
|
1750
|
+
worktree,
|
|
1751
|
+
"review-run",
|
|
1752
|
+
"REVIEW-RETRY-REPAIR",
|
|
1753
|
+
"--reviewer",
|
|
1754
|
+
"repair-reviewer",
|
|
1755
|
+
"--runner-command-json",
|
|
1756
|
+
blocked_runner,
|
|
1757
|
+
check=False,
|
|
1758
|
+
)
|
|
1759
|
+
manifest_path = self.registry_manifest_path(repo, "REVIEW-RETRY-REPAIR")
|
|
1760
|
+
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
1761
|
+
manifest["skill_version"] = "4.3.2"
|
|
1762
|
+
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
1763
|
+
fingerprint = manifest["review"]["diff_fingerprint"]
|
|
1764
|
+
first_retry = json.loads(
|
|
1765
|
+
self.ap_script(
|
|
1766
|
+
worktree,
|
|
1767
|
+
managed_434,
|
|
1768
|
+
"review-runtime-retry",
|
|
1769
|
+
"REVIEW-RETRY-REPAIR",
|
|
1770
|
+
"--diff-fingerprint",
|
|
1771
|
+
fingerprint,
|
|
1772
|
+
"--reason-code",
|
|
1773
|
+
"managed-review-artifact-access",
|
|
1774
|
+
"--confirm-managed-runtime-retry",
|
|
1775
|
+
"--json",
|
|
1776
|
+
).stdout
|
|
1777
|
+
)
|
|
1778
|
+
self.assertEqual("retry-v4.3.4", first_retry["retry_token"])
|
|
1779
|
+
self.ap_script(
|
|
1780
|
+
worktree,
|
|
1781
|
+
managed_434,
|
|
1782
|
+
"review-run",
|
|
1783
|
+
"REVIEW-RETRY-REPAIR",
|
|
1784
|
+
"--reviewer",
|
|
1785
|
+
"repair-reviewer",
|
|
1786
|
+
"--runner-command-json",
|
|
1787
|
+
blocked_runner,
|
|
1788
|
+
check=False,
|
|
1789
|
+
)
|
|
1790
|
+
blocked_status = json.loads(
|
|
1791
|
+
self.ap_script(
|
|
1792
|
+
worktree,
|
|
1793
|
+
managed_434,
|
|
1794
|
+
"task-status",
|
|
1795
|
+
"REVIEW-RETRY-REPAIR",
|
|
1796
|
+
"--json",
|
|
1797
|
+
).stdout
|
|
1798
|
+
)["tasks"][0]
|
|
1799
|
+
old_review = blocked_status["review"]
|
|
1800
|
+
old_evidence_paths = [
|
|
1801
|
+
Path(old_review["runtime_retry_audit_path"]),
|
|
1802
|
+
Path(old_review["runtime_result_path"]),
|
|
1803
|
+
Path(old_review["runtime_receipt_path"]),
|
|
1804
|
+
Path(old_review["runtime_event_log_path"]),
|
|
1805
|
+
]
|
|
1806
|
+
old_evidence = {path: path.read_bytes() for path in old_evidence_paths}
|
|
1807
|
+
|
|
1808
|
+
repaired = json.loads(
|
|
1809
|
+
self.ap_script(
|
|
1810
|
+
worktree,
|
|
1811
|
+
managed_435,
|
|
1812
|
+
"review-runtime-retry",
|
|
1813
|
+
"REVIEW-RETRY-REPAIR",
|
|
1814
|
+
"--diff-fingerprint",
|
|
1815
|
+
fingerprint,
|
|
1816
|
+
"--reason-code",
|
|
1817
|
+
"managed-review-artifact-access",
|
|
1818
|
+
"--confirm-managed-runtime-retry",
|
|
1819
|
+
"--json",
|
|
1820
|
+
).stdout
|
|
1821
|
+
)
|
|
1822
|
+
self.assertEqual("retry-v4.3.5", repaired["retry_token"])
|
|
1823
|
+
repair_audit = json.loads(Path(repaired["audit_path"]).read_text(encoding="utf-8"))
|
|
1824
|
+
self.assertEqual("retry-v4.3.4", repair_audit["superseded_retry_token"])
|
|
1825
|
+
self.assertEqual("blocked", repair_audit["superseded_retry_state"])
|
|
1826
|
+
reviewed = json.loads(
|
|
1827
|
+
self.ap_script(
|
|
1828
|
+
worktree,
|
|
1829
|
+
managed_435,
|
|
1830
|
+
"review-run",
|
|
1831
|
+
"REVIEW-RETRY-REPAIR",
|
|
1832
|
+
"--reviewer",
|
|
1833
|
+
"repair-reviewer",
|
|
1834
|
+
"--runner-command-json",
|
|
1835
|
+
self.artifact_reviewer_runner(
|
|
1836
|
+
root,
|
|
1837
|
+
"repair retry payload",
|
|
1838
|
+
runtime_script=managed_435,
|
|
1839
|
+
),
|
|
1840
|
+
"--json",
|
|
1841
|
+
).stdout
|
|
1842
|
+
)
|
|
1843
|
+
self.assertEqual("approved", reviewed["verdict"])
|
|
1844
|
+
for path, original in old_evidence.items():
|
|
1845
|
+
self.assertEqual(original, path.read_bytes(), str(path))
|
|
1846
|
+
|
|
1847
|
+
def test_managed_retry_rejects_a_substantive_blocked_result(self) -> None:
|
|
1848
|
+
root, repo, _ = self.make_repo()
|
|
1849
|
+
managed_script = self.managed_runtime(root)
|
|
1850
|
+
worktree = self.start_task(repo, "REVIEW-RETRY-FINDING", "shared.txt")
|
|
1851
|
+
(worktree / "shared.txt").write_text("substantive retry rejection\n", encoding="utf-8")
|
|
1852
|
+
reviewer = root / "substantive-block.py"
|
|
1853
|
+
reviewer.write_text(
|
|
1854
|
+
"import json\n"
|
|
1855
|
+
"print(json.dumps({'verdict': 'blocked', 'summary': 'real correctness defect', "
|
|
1856
|
+
"'findings': ['P1: incorrect authorization check'], "
|
|
1857
|
+
"'risks': ['Production authorization can be bypassed.']}))\n",
|
|
1858
|
+
encoding="utf-8",
|
|
1859
|
+
)
|
|
1860
|
+
self.ap(
|
|
1861
|
+
worktree,
|
|
1862
|
+
"review-run",
|
|
1863
|
+
"REVIEW-RETRY-FINDING",
|
|
1864
|
+
"--reviewer",
|
|
1865
|
+
"finding-reviewer",
|
|
1866
|
+
"--runner-command-json",
|
|
1867
|
+
json.dumps([sys.executable, str(reviewer)]),
|
|
1868
|
+
check=False,
|
|
1869
|
+
)
|
|
1870
|
+
manifest_path = self.registry_manifest_path(repo, "REVIEW-RETRY-FINDING")
|
|
1871
|
+
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
1872
|
+
manifest["skill_version"] = "4.3.2"
|
|
1873
|
+
manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
|
|
1874
|
+
rejected = self.ap_script(
|
|
1875
|
+
worktree,
|
|
1876
|
+
managed_script,
|
|
1877
|
+
"review-runtime-retry",
|
|
1878
|
+
"REVIEW-RETRY-FINDING",
|
|
1879
|
+
"--diff-fingerprint",
|
|
1880
|
+
manifest["review"]["diff_fingerprint"],
|
|
1881
|
+
"--reason-code",
|
|
1882
|
+
"managed-review-artifact-access",
|
|
1883
|
+
"--confirm-managed-runtime-retry",
|
|
1884
|
+
check=False,
|
|
1885
|
+
)
|
|
1886
|
+
self.assertNotEqual(0, rejected.returncode)
|
|
1887
|
+
self.assertIn("not the exact non-substantive", rejected.stdout + rejected.stderr)
|
|
1888
|
+
|
|
1556
1889
|
def test_review_run_retries_runtime_unavailable_and_allows_bound_user_override(self) -> None:
|
|
1557
1890
|
root, repo, _ = self.make_repo()
|
|
1558
1891
|
worktree = self.start_task(repo, "REVIEW-TIMEOUT", "shared.txt")
|
|
@@ -87,7 +87,7 @@ class ProjectConfigResolverTests(unittest.TestCase):
|
|
|
87
87
|
(self.repo / "docs" / "project").mkdir(parents=True)
|
|
88
88
|
self.write_managed(
|
|
89
89
|
"""workflow:
|
|
90
|
-
skill_version: "4.3.
|
|
90
|
+
skill_version: "4.3.5"
|
|
91
91
|
mode: dev
|
|
92
92
|
profile: auto
|
|
93
93
|
completion: push
|
|
@@ -130,7 +130,7 @@ access:
|
|
|
130
130
|
effective = core.load_effective_config(self.repo)
|
|
131
131
|
|
|
132
132
|
self.assertEqual("sample", effective["project"]["name"])
|
|
133
|
-
self.assertEqual("4.3.
|
|
133
|
+
self.assertEqual("4.3.5", effective["workflow"]["skill_version"])
|
|
134
134
|
self.assertEqual(self.repo / "docs" / "ENGINEERING.md", core.find_config(self.repo))
|
|
135
135
|
self.assertEqual({}, core.load_project_overrides(self.repo))
|
|
136
136
|
|
|
@@ -153,7 +153,7 @@ access:
|
|
|
153
153
|
|
|
154
154
|
effective = core.load_effective_config(self.repo)
|
|
155
155
|
|
|
156
|
-
self.assertEqual("4.3.
|
|
156
|
+
self.assertEqual("4.3.5", effective["workflow"]["skill_version"])
|
|
157
157
|
self.assertEqual("dev", effective["workflow"]["mode"])
|
|
158
158
|
self.assertEqual("project-profile", effective["workflow"]["profile"])
|
|
159
159
|
self.assertEqual("push", effective["workflow"]["completion"])
|
|
@@ -292,11 +292,11 @@ access:
|
|
|
292
292
|
|
|
293
293
|
def test_large_managed_body_is_not_part_of_frontmatter_bound(self) -> None:
|
|
294
294
|
self.write_managed(
|
|
295
|
-
'workflow:\n skill_version: "4.3.
|
|
295
|
+
'workflow:\n skill_version: "4.3.5"\n',
|
|
296
296
|
body="x" * (core.MANAGED_CONFIG_FRONTMATTER_MAX_BYTES + 1),
|
|
297
297
|
)
|
|
298
298
|
|
|
299
|
-
self.assertEqual("4.3.
|
|
299
|
+
self.assertEqual("4.3.5", core.load_effective_config(self.repo)["workflow"]["skill_version"])
|
|
300
300
|
|
|
301
301
|
def test_yaml_failure_does_not_echo_content_or_absolute_path(self) -> None:
|
|
302
302
|
secret = "NEVER_ECHO_THIS_SECRET"
|