@elvis1513/auto-coding-skill 4.3.7 → 5.0.1

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.
Files changed (34) hide show
  1. package/README.md +30 -761
  2. package/cli/assets/managed-install.json +42 -1
  3. package/cli/assets/skill/SKILL.md +17 -100
  4. package/cli/assets/skill/data/templates/ENVIRONMENT.md +34 -0
  5. package/cli/assets/skill/data/templates/PROJECT.md +30 -0
  6. package/cli/assets/skill/data/templates/architecture/.gitkeep +1 -0
  7. package/cli/assets/skill/data/templates/bridges/AGENTS.md +52 -157
  8. package/cli/assets/skill/data/templates/deployment/.gitkeep +1 -0
  9. package/cli/assets/skill/data/templates/design/.gitkeep +1 -0
  10. package/cli/assets/skill/data/templates/interfaces/.gitkeep +1 -0
  11. package/cli/assets/skill/data/templates/product/.gitkeep +1 -0
  12. package/cli/src/index.js +154 -2585
  13. package/cli/src/sync-assets.js +38 -95
  14. package/package.json +9 -17
  15. package/cli/assets/agents/browser-debugger.toml +0 -27
  16. package/cli/assets/agents/docs-researcher.toml +0 -18
  17. package/cli/assets/agents/explorer.toml +0 -26
  18. package/cli/assets/agents/fixer.toml +0 -29
  19. package/cli/assets/agents/reviewer.toml +0 -50
  20. package/cli/assets/skill/data/contracts/orchestration-v1.schema.json +0 -567
  21. package/cli/assets/skill/data/policies/feedback-resolutions-v1.json +0 -68
  22. package/cli/assets/skill/data/policies/workflow-migrations-v1.json +0 -657
  23. package/cli/assets/skill/data/templates/ENGINEERING.md +0 -115
  24. package/cli/assets/skill/data/templates/tools/ap.py +0 -16
  25. package/cli/assets/skill/requirements.txt +0 -1
  26. package/cli/assets/skill/scripts/ap.py +0 -17791
  27. package/cli/assets/skill/scripts/core.py +0 -510
  28. package/cli/assets/skill/scripts/http_checks.py +0 -92
  29. package/cli/assets/skill/scripts/install_integrity.py +0 -427
  30. package/cli/assets/skill/scripts/scaffold_templates.py +0 -325
  31. package/cli/tests/ap_concurrency_test.py +0 -3602
  32. package/cli/tests/ap_profiles_test.py +0 -3272
  33. package/cli/tests/core_shell_test.py +0 -345
  34. package/cli/tests/index.test.js +0 -2967
@@ -1,3602 +0,0 @@
1
- #!/usr/bin/env python3
2
- from __future__ import annotations
3
-
4
- import hashlib
5
- import json
6
- import os
7
- import shutil
8
- import subprocess
9
- import sys
10
- import tempfile
11
- import time
12
- import unittest
13
- from datetime import datetime, timedelta, timezone
14
- from concurrent.futures import ThreadPoolExecutor
15
- from pathlib import Path
16
-
17
- import yaml
18
-
19
-
20
- REPO_ROOT = Path(__file__).resolve().parents[2]
21
- AP_SCRIPT = REPO_ROOT / "src" / "auto-coding-skill" / "scripts" / "ap.py"
22
- _MISSING = object()
23
- _TEST_OWNER = os.environ.get("CODEX_THREAD_ID") or "concurrency-test-owner"
24
-
25
-
26
- def command(
27
- cwd: Path,
28
- *args: str,
29
- check: bool = True,
30
- input_text: str | None = None,
31
- ) -> subprocess.CompletedProcess[str]:
32
- env = os.environ.copy()
33
- env.setdefault("CODEX_THREAD_ID", _TEST_OWNER)
34
- env.setdefault("AUTOCODING_TEST_RUNNER_OVERRIDE", "1")
35
- result = subprocess.run(
36
- list(args),
37
- cwd=cwd,
38
- check=False,
39
- text=True,
40
- input=input_text,
41
- capture_output=True,
42
- timeout=30,
43
- env=env,
44
- )
45
- if check and result.returncode != 0:
46
- raise AssertionError(
47
- f"command failed ({result.returncode}): {' '.join(args)}\n"
48
- f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
49
- )
50
- return result
51
-
52
-
53
- def git(cwd: Path, *args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
54
- return command(cwd, "git", *args, check=check)
55
-
56
-
57
- def git_output(cwd: Path, *args: str) -> str:
58
- return git(cwd, *args).stdout.strip()
59
-
60
-
61
- def base_config(isolation: str | object = "adaptive") -> dict:
62
- config = {
63
- "workflow": {"mode": "dev", "profile": "auto", "completion": "push"},
64
- "project": {"name": "concurrency-test"},
65
- "access": {
66
- "project": {
67
- "frontend": {"url": "https://project-front.test", "username": "front", "password": "front-pass"},
68
- "backend": {"url": "https://project-back.test", "username": "back", "password": "back-pass"},
69
- },
70
- "jenkins": {
71
- "frontend": {"url": "https://jenkins-front.test", "username": "front", "password": "front-pass"},
72
- "backend": {"url": "https://jenkins-back.test", "username": "back", "password": "back-pass"},
73
- },
74
- "gitlab": {"url": "https://gitlab.test", "username": "git", "password": "git-pass"},
75
- "nexus": {
76
- "frontend": {"url": "https://nexus.test", "username": "nexus", "password": "nexus-pass"},
77
- },
78
- },
79
- "commands": {
80
- "gate_changed": "true",
81
- "gate_standard": "true",
82
- "gate_full": "true",
83
- },
84
- "gate": {
85
- "default_scope": "changed",
86
- "fallback_scope": "changed",
87
- "full_on_unknown": False,
88
- "no_change_scope": "changed",
89
- "rules": [],
90
- },
91
- "risk": {
92
- "rules": [
93
- {"name": "test-review", "paths": ["**"], "review": "required"},
94
- ],
95
- },
96
- "structure": {"enabled": False, "enforcement": "advisory"},
97
- "verification": {
98
- "target_env_required": False,
99
- "jenkins_required": False,
100
- },
101
- "docs": {
102
- "taskbook": "docs/tasks/taskbook.md",
103
- "closure_log": "docs/tasks/closure-log.md",
104
- "evidence_log": "docs/tasks/evidence.jsonl",
105
- "design_dir": "docs/design",
106
- "ledger_check_enabled": False,
107
- },
108
- }
109
- if isolation is not _MISSING:
110
- config["concurrency"] = {
111
- "isolation": isolation,
112
- "base_ref": "origin/dev",
113
- "target_branch": "dev",
114
- "branch_prefix": "codex/",
115
- # Tests replace this with an absolute path outside the primary checkout.
116
- "worktree_root": "",
117
- "cleanup_merged": True,
118
- "delete_remote_branch": True,
119
- }
120
- return config
121
-
122
-
123
- class AutoCodingConcurrencyTests(unittest.TestCase):
124
- def make_repo(
125
- self,
126
- isolation: str | object = "worktree",
127
- *,
128
- require_review: bool = True,
129
- ) -> tuple[Path, Path, Path]:
130
- temp = tempfile.TemporaryDirectory(prefix="autocoding-concurrency-")
131
- self.addCleanup(temp.cleanup)
132
- root = Path(temp.name)
133
- repo = root / "project"
134
- remote = root / "origin.git"
135
- worktrees = root / "worktrees"
136
- repo.mkdir()
137
-
138
- git(root, "init", "--bare", "-q", str(remote))
139
- git(repo, "init", "-q", "-b", "dev")
140
- git(repo, "config", "user.email", "test@example.com")
141
- git(repo, "config", "user.name", "Auto Coding Test")
142
-
143
- config = base_config(isolation)
144
- if not require_review:
145
- config["risk"]["rules"] = []
146
- if "concurrency" in config:
147
- config["concurrency"]["worktree_root"] = str(worktrees)
148
- engineering = repo / "docs" / "ENGINEERING.md"
149
- engineering.parent.mkdir(parents=True)
150
- engineering.write_text(
151
- "---\n"
152
- + yaml.safe_dump(config, allow_unicode=True, sort_keys=False)
153
- + "---\n# Engineering\n",
154
- encoding="utf-8",
155
- )
156
- tasks = repo / "docs" / "tasks"
157
- tasks.mkdir(parents=True)
158
- (tasks / "taskbook.md").write_text("# Taskbook\n", encoding="utf-8")
159
- (tasks / "closure-log.md").write_text("# Closure Log\n", encoding="utf-8")
160
- (repo / "shared.txt").write_text("baseline\n", encoding="utf-8")
161
- git(repo, "add", "-A")
162
- git(repo, "commit", "-qm", "baseline")
163
- git(repo, "remote", "add", "origin", str(remote))
164
- git(repo, "push", "-qu", "origin", "dev")
165
- git(remote, "symbolic-ref", "HEAD", "refs/heads/dev")
166
- return root, repo, remote
167
-
168
- def ap(
169
- self,
170
- repo: Path,
171
- *args: str,
172
- check: bool = True,
173
- ) -> subprocess.CompletedProcess[str]:
174
- return command(
175
- repo,
176
- sys.executable,
177
- str(AP_SCRIPT),
178
- "--repo",
179
- str(repo),
180
- *args,
181
- check=check,
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.7") -> 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
-
230
- def approve_task(self, repo: Path, task_id: str) -> str:
231
- issued = json.loads(
232
- self.ap(
233
- repo,
234
- "review-assignment",
235
- task_id,
236
- "--reviewer",
237
- "test-reviewer",
238
- "--json",
239
- ).stdout
240
- )
241
- fingerprint = issued["assignment"]["diff_fingerprint"]
242
- self.ap(
243
- repo,
244
- "task-review",
245
- task_id,
246
- "--verdict",
247
- "approved",
248
- "--diff-fingerprint",
249
- fingerprint,
250
- "--reviewer",
251
- "test-reviewer",
252
- )
253
- return fingerprint
254
-
255
- def claim_direct(self, repo: Path, *owned_paths: str) -> str:
256
- args: list[str] = ["classify", "--task-kind", "change", "--claim-direct", "--json"]
257
- for path in owned_paths:
258
- args.extend(["--planned-path", path])
259
- payload = json.loads(self.ap(repo, *args).stdout)
260
- return payload["direct_claim"]["id"]
261
-
262
- def commit_push(self, repo: Path, task_id: str, message: str) -> subprocess.CompletedProcess[str]:
263
- self.approve_task(repo, task_id)
264
- return self.ap(repo, "commit-push", task_id, "--msg", message)
265
-
266
- def artifact_reviewer_runner(
267
- self,
268
- root: Path,
269
- *tokens: str,
270
- runtime_script: Path = AP_SCRIPT,
271
- ) -> str:
272
- fake_reviewer = root / "fake-artifact-reviewer.py"
273
- fake_reviewer.write_text(
274
- "import hashlib, json, os, pathlib, subprocess, sys\n"
275
- "if os.environ.get('CODEX_THREAD_ID'):\n"
276
- " raise SystemExit(9)\n"
277
- "assignment_path = pathlib.Path(os.environ['AUTOCODING_REVIEW_ASSIGNMENT'])\n"
278
- "assignment_bytes = assignment_path.read_bytes()\n"
279
- "if hashlib.sha256(assignment_bytes).hexdigest() != os.environ['AUTOCODING_REVIEW_ASSIGNMENT_SHA256']:\n"
280
- " raise SystemExit(10)\n"
281
- "assignment = json.loads(assignment_bytes)\n"
282
- "artifact_path = pathlib.Path(assignment['diff_artifact_path'])\n"
283
- "emitted = subprocess.run([sys.executable, sys.argv[1], '--repo', str(pathlib.Path.cwd()), "
284
- "'review-artifact', '--file', str(assignment_path)], capture_output=True, check=False)\n"
285
- "if emitted.returncode != 0:\n"
286
- " raise SystemExit(11)\n"
287
- "payload = emitted.stdout\n"
288
- "actual = hashlib.sha256(payload).hexdigest()\n"
289
- "if actual != assignment['diff_artifact_sha256']:\n"
290
- " raise SystemExit(12)\n"
291
- "if os.environ.get('AUTOCODING_REVIEW_DIFF_ARTIFACT') != str(artifact_path):\n"
292
- " raise SystemExit(13)\n"
293
- "if os.environ.get('AUTOCODING_REVIEW_DIFF_ARTIFACT_SHA256') != actual:\n"
294
- " raise SystemExit(14)\n"
295
- "if int(os.environ['AUTOCODING_REVIEW_TIMEOUT_SECONDS']) not in (150, 360):\n"
296
- " raise SystemExit(15)\n"
297
- "for token in sys.argv[2:]:\n"
298
- " if token.encode('utf-8') not in payload:\n"
299
- " raise SystemExit(16)\n"
300
- "print(json.dumps({'verdict': 'approved', 'summary': 'artifact reviewed', "
301
- "'evidence': ['diff_artifact_sha256=' + actual]}))\n",
302
- encoding="utf-8",
303
- )
304
- return json.dumps([sys.executable, str(fake_reviewer), str(runtime_script), *tokens])
305
-
306
- def task_worktree(self, repo: Path, task_id: str) -> Path:
307
- wanted = f"refs/heads/codex/{task_id}"
308
- current_path: Path | None = None
309
- for line in git_output(repo, "worktree", "list", "--porcelain").splitlines():
310
- if line.startswith("worktree "):
311
- current_path = Path(line.removeprefix("worktree "))
312
- elif line == f"branch {wanted}" and current_path is not None:
313
- return current_path
314
- self.fail(f"no worktree registered for {wanted}")
315
-
316
- def start_task(self, repo: Path, task_id: str, owned_path: str = ".") -> Path:
317
- result = self.ap(
318
- repo,
319
- "task-start",
320
- task_id,
321
- "--base",
322
- "origin/dev",
323
- "--owned-path",
324
- owned_path,
325
- "--isolated",
326
- "--review-required",
327
- )
328
- worktree = self.task_worktree(repo, task_id)
329
- self.assertIn(task_id, result.stdout + result.stderr)
330
- self.assertTrue(worktree.is_dir())
331
- self.assertNotEqual(repo.resolve(), worktree.resolve())
332
- self.assertNotIn(repo.resolve(), worktree.resolve().parents)
333
- self.assertEqual(f"codex/{task_id}", git_output(worktree, "branch", "--show-current"))
334
- return worktree
335
-
336
- def assert_local_branch(self, repo: Path, branch: str, exists: bool) -> None:
337
- result = git(repo, "show-ref", "--verify", "--quiet", f"refs/heads/{branch}", check=False)
338
- self.assertEqual(exists, result.returncode == 0, branch)
339
-
340
- def assert_remote_branch(self, remote: Path, branch: str, exists: bool) -> None:
341
- result = git(
342
- remote,
343
- "show-ref",
344
- "--verify",
345
- "--quiet",
346
- f"refs/heads/{branch}",
347
- check=False,
348
- )
349
- self.assertEqual(exists, result.returncode == 0, branch)
350
-
351
- def assert_rejected_without_mutation(
352
- self,
353
- repo: Path,
354
- *args: str,
355
- ) -> subprocess.CompletedProcess[str]:
356
- before_head = git_output(repo, "rev-parse", "HEAD")
357
- before_status = git_output(repo, "status", "--porcelain=v1", "--untracked-files=all")
358
- result = self.ap(repo, *args, check=False)
359
- self.assertNotEqual(0, result.returncode, result.stdout + result.stderr)
360
- self.assertEqual(before_head, git_output(repo, "rev-parse", "HEAD"))
361
- self.assertEqual(
362
- before_status,
363
- git_output(repo, "status", "--porcelain=v1", "--untracked-files=all"),
364
- )
365
- return result
366
-
367
- def test_task_start_rejects_unknown_full_gate_policy_before_creating_branch(self) -> None:
368
- _, repo, _ = self.make_repo()
369
- (repo / "AGENTS.md").write_text(
370
- "# Workflow\n- High-risk work\n must run the real full gate before push.\n",
371
- encoding="utf-8",
372
- )
373
- result = self.ap(
374
- repo,
375
- "task-start",
376
- "POLICY-START",
377
- "--base",
378
- "origin/dev",
379
- "--owned-path",
380
- ".",
381
- check=False,
382
- )
383
- self.assertNotEqual(0, result.returncode)
384
- self.assertIn("AGENTS.md:2", result.stdout + result.stderr)
385
- self.assert_local_branch(repo, "codex/POLICY-START", False)
386
-
387
- def test_task_start_rejects_owner_and_writer_that_conflict_with_runtime_identity(self) -> None:
388
- _, repo, _ = self.make_repo()
389
- for field in ("owner", "writer"):
390
- with self.subTest(field=field):
391
- task_id = f"IDENTITY-{field.upper()}"
392
- rejected = self.ap(
393
- repo,
394
- "task-start",
395
- task_id,
396
- "--base",
397
- "origin/dev",
398
- "--owned-path",
399
- "shared.txt",
400
- "--isolated",
401
- "--review-required",
402
- f"--{field}",
403
- "different-runtime-actor",
404
- check=False,
405
- )
406
- self.assertNotEqual(0, rejected.returncode)
407
- self.assertIn("does not match CODEX_THREAD_ID", rejected.stdout + rejected.stderr)
408
- self.assertFalse(self.registry_manifest_path(repo, task_id).exists())
409
- self.assert_local_branch(repo, f"codex/{task_id}", False)
410
-
411
- def test_task_start_rejects_legacy_gate_yaml_before_creating_branch(self) -> None:
412
- _, repo, _ = self.make_repo()
413
- engineering = repo / "docs" / "ENGINEERING.md"
414
- text = engineering.read_text(encoding="utf-8").replace(
415
- " full_on_unknown: false\n",
416
- " full_on_unknown: true\n full_on:\n - prod_config\n",
417
- ).replace(
418
- " rules: []\n",
419
- " rules:\n - match:\n - Jenkinsfile\n scope: full\n commands:\n - gate_full\n",
420
- )
421
- engineering.write_text(text, encoding="utf-8")
422
- result = self.ap(
423
- repo,
424
- "task-start",
425
- "POLICY-YAML",
426
- "--base",
427
- "origin/dev",
428
- "--owned-path",
429
- ".",
430
- check=False,
431
- )
432
- self.assertNotEqual(0, result.returncode)
433
- self.assertIn("gate.full_on", result.stdout + result.stderr)
434
- self.assertIn("gate.rules[0].scope", result.stdout + result.stderr)
435
- self.assert_local_branch(repo, "codex/POLICY-YAML", False)
436
-
437
- def test_commit_push_rejects_policy_added_after_task_start(self) -> None:
438
- _, repo, _ = self.make_repo()
439
- worktree = self.start_task(repo, "POLICY-PUSH")
440
- (worktree / "AGENTS.md").write_text(
441
- "# Workflow\nRuntime changes require the full gate.\n",
442
- encoding="utf-8",
443
- )
444
- self.approve_task(worktree, "POLICY-PUSH")
445
- result = self.ap(
446
- worktree,
447
- "commit-push",
448
- "POLICY-PUSH",
449
- "--msg",
450
- "POLICY-PUSH: blocked",
451
- check=False,
452
- )
453
- self.assertNotEqual(0, result.returncode)
454
- self.assertIn("AGENTS.md:2", result.stdout + result.stderr)
455
- self.assertEqual("", git_output(worktree, "diff", "--cached", "--name-only"))
456
-
457
- def manifest_payloads(self, repo: Path) -> list[dict]:
458
- common_dir_raw = git_output(repo, "rev-parse", "--git-common-dir")
459
- common_dir = Path(common_dir_raw)
460
- if not common_dir.is_absolute():
461
- common_dir = (repo / common_dir).resolve()
462
- payloads: list[dict] = []
463
- for candidate in common_dir.rglob("*.json"):
464
- try:
465
- payload = json.loads(candidate.read_text(encoding="utf-8"))
466
- except (OSError, UnicodeDecodeError, json.JSONDecodeError):
467
- continue
468
- if isinstance(payload, dict):
469
- payloads.append(payload)
470
- return payloads
471
-
472
- def registry_manifest_path(self, repo: Path, task_id: str) -> Path:
473
- common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
474
- if not common_dir.is_absolute():
475
- common_dir = (repo / common_dir).resolve()
476
- return common_dir / "auto-coding-skill" / "tasks" / f"{task_id}.json"
477
-
478
- def shorten_review_deadline(
479
- self,
480
- repo: Path,
481
- task_id: str,
482
- issued: dict,
483
- seconds: int = 2,
484
- ) -> None:
485
- deadline = datetime.now(timezone.utc).replace(microsecond=0) + timedelta(seconds=seconds)
486
- assignment = issued["assignment"]
487
- assignment["deadline_at"] = deadline.isoformat()
488
- assignment["issued_at"] = (deadline - timedelta(seconds=150)).isoformat()
489
- assignment_path = Path(issued["assignment_path"])
490
- assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
491
- manifest_path = self.registry_manifest_path(repo, task_id)
492
- manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
493
- manifest["review"]["issued_at"] = assignment["issued_at"]
494
- manifest["review"]["deadline_at"] = assignment["deadline_at"]
495
- manifest["review"]["assignment_sha256"] = hashlib.sha256(
496
- assignment_path.read_bytes()
497
- ).hexdigest()
498
- manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
499
-
500
- def install_hook(self, repo: Path, name: str, body: str) -> Path:
501
- common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
502
- if not common_dir.is_absolute():
503
- common_dir = (repo / common_dir).resolve()
504
- hook = common_dir / "hooks" / name
505
- hook.write_text("#!/bin/sh\nset -eu\n" + body, encoding="utf-8")
506
- hook.chmod(0o755)
507
- return hook
508
-
509
- def update_config(self, repo: Path, update) -> None:
510
- engineering = repo / "docs" / "ENGINEERING.md"
511
- raw = engineering.read_text(encoding="utf-8")
512
- _, frontmatter, body = raw.split("---", 2)
513
- config = yaml.safe_load(frontmatter)
514
- update(config)
515
- engineering.write_text(
516
- "---\n"
517
- + yaml.safe_dump(config, allow_unicode=True, sort_keys=False)
518
- + "---"
519
- + body,
520
- encoding="utf-8",
521
- )
522
- git(repo, "add", "docs/ENGINEERING.md")
523
- git(repo, "commit", "-qm", "update test workflow config")
524
- git(repo, "push", "-q", "origin", "dev")
525
-
526
- def test_task_start_creates_external_worktree_manifest_and_status(self) -> None:
527
- _, repo, _ = self.make_repo()
528
- worktree = self.start_task(repo, "START-1")
529
-
530
- status = self.ap(repo, "task-status", "START-1")
531
- rendered_status = status.stdout + status.stderr
532
- self.assertIn("START-1", rendered_status)
533
- self.assertIn("codex/START-1", rendered_status)
534
- self.assertIn(str(worktree), rendered_status)
535
- status_payload = json.loads(
536
- self.ap(repo, "task-status", "START-1", "--json").stdout
537
- )["tasks"][0]
538
- self.assertFalse(status_payload["has_task_commits"])
539
- self.assertFalse(status_payload["merged_into_target"])
540
-
541
- serialized_payloads = [json.dumps(item, sort_keys=True) for item in self.manifest_payloads(repo)]
542
- self.assertTrue(
543
- any(
544
- "START-1" in payload
545
- and "codex/START-1" in payload
546
- and str(worktree) in payload
547
- for payload in serialized_payloads
548
- ),
549
- "task-start must persist a task manifest in the Git common directory",
550
- )
551
- self.assertFalse(
552
- (worktree / "docs" / "tasks" / "active" / "START-1.md").exists(),
553
- "4.0 machine state must not create tracked active-task documents",
554
- )
555
-
556
- def test_clean_serial_task_uses_direct_branch_and_no_diff_is_noop(self) -> None:
557
- _, repo, remote = self.make_repo("adaptive", require_review=False)
558
- worktrees_before = git_output(repo, "worktree", "list", "--porcelain")
559
- unnecessary = self.ap(
560
- repo,
561
- "task-start",
562
- "DIRECT-SKIP",
563
- "--base",
564
- "origin/dev",
565
- "--owned-path",
566
- "shared.txt",
567
- check=False,
568
- )
569
- self.assertNotEqual(0, unnecessary.returncode)
570
- self.assertIn("does not need a machine task lifecycle", unnecessary.stdout + unnecessary.stderr)
571
- self.assertFalse(self.registry_manifest_path(repo, "DIRECT-SKIP").exists())
572
- start = self.ap(
573
- repo,
574
- "task-start",
575
- "DIRECT-1",
576
- "--base",
577
- "origin/dev",
578
- "--owned-path",
579
- "shared.txt",
580
- "--force-lifecycle",
581
- )
582
- self.assertIn("execution_mode=direct", start.stdout)
583
- self.assertEqual(worktrees_before, git_output(repo, "worktree", "list", "--porcelain"))
584
- self.assert_local_branch(repo, "codex/DIRECT-1", False)
585
- status = json.loads(self.ap(repo, "task-status", "DIRECT-1", "--json").stdout)["tasks"][0]
586
- self.assertEqual("direct", status["execution_mode"])
587
- self.assertFalse(status["has_task_commits"])
588
- self.assertFalse(status["merged_into_target"])
589
- self.assertFalse((repo / "docs" / "tasks" / "active" / "DIRECT-1.md").exists())
590
-
591
- (repo / "shared.txt").write_text("direct\n", encoding="utf-8")
592
- pushed = self.ap(repo, "commit-push", "DIRECT-1", "--msg", "DIRECT-1: update")
593
- self.assertIn("execution_mode=direct", pushed.stdout)
594
- self.assertEqual("direct", git_output(remote, "show", "refs/heads/dev:shared.txt"))
595
- self.assertFalse(self.registry_manifest_path(repo, "DIRECT-1").exists())
596
-
597
- before = git_output(repo, "rev-parse", "HEAD")
598
- self.ap(repo, "task-start", "DIRECT-NOOP", "--owned-path", "shared.txt", "--force-lifecycle")
599
- noop = self.ap(repo, "commit-push", "DIRECT-NOOP", "--msg", "DIRECT-NOOP: none")
600
- self.assertIn("NOOP", noop.stdout)
601
- self.assertEqual(before, git_output(repo, "rev-parse", "HEAD"))
602
- self.assertFalse(self.registry_manifest_path(repo, "DIRECT-NOOP").exists())
603
-
604
- def test_commit_push_accepts_already_staged_deletion(self) -> None:
605
- _, repo, remote = self.make_repo()
606
- worktree = self.start_task(repo, "STAGED-DELETE", "shared.txt")
607
- (worktree / "shared.txt").unlink()
608
- git(worktree, "add", "-A", "--", "shared.txt")
609
- self.approve_task(worktree, "STAGED-DELETE")
610
-
611
- result = self.ap(
612
- worktree,
613
- "commit-push",
614
- "STAGED-DELETE",
615
- "--msg",
616
- "STAGED-DELETE: remove shared file",
617
- )
618
-
619
- self.assertIn("commit-push", result.stdout)
620
- self.assertNotEqual(
621
- 0,
622
- git(
623
- remote,
624
- "cat-file",
625
- "-e",
626
- "refs/heads/codex/STAGED-DELETE:shared.txt",
627
- check=False,
628
- ).returncode,
629
- )
630
- self.assertEqual("", git_output(worktree, "status", "--short"))
631
-
632
- def test_staged_rename_requires_ownership_of_both_paths(self) -> None:
633
- _, repo, remote = self.make_repo()
634
- worktree = self.start_task(repo, "RENAME-DENY", "renamed.txt")
635
- git(worktree, "mv", "shared.txt", "renamed.txt")
636
- status = json.loads(self.ap(worktree, "task-status", "RENAME-DENY", "--json").stdout)
637
- fingerprint = status["tasks"][0]["current_diff_fingerprint"]
638
-
639
- denied = self.ap(
640
- worktree,
641
- "task-review",
642
- "RENAME-DENY",
643
- "--verdict",
644
- "approved",
645
- "--diff-fingerprint",
646
- fingerprint,
647
- "--reviewer",
648
- "test-reviewer",
649
- check=False,
650
- )
651
-
652
- self.assertNotEqual(0, denied.returncode)
653
- self.assertIn("shared.txt", denied.stdout + denied.stderr)
654
- self.assert_remote_branch(remote, "codex/RENAME-DENY", False)
655
-
656
- _, allowed_repo, allowed_remote = self.make_repo()
657
- started = self.ap(
658
- allowed_repo,
659
- "task-start",
660
- "RENAME-ALLOW",
661
- "--base",
662
- "origin/dev",
663
- "--owned-path",
664
- "shared.txt",
665
- "--owned-path",
666
- "renamed.txt",
667
- "--isolated",
668
- "--review-required",
669
- )
670
- self.assertIn("RENAME-ALLOW", started.stdout)
671
- allowed_worktree = self.task_worktree(allowed_repo, "RENAME-ALLOW")
672
- git(allowed_worktree, "mv", "shared.txt", "renamed.txt")
673
- self.commit_push(allowed_worktree, "RENAME-ALLOW", "RENAME-ALLOW: rename shared file")
674
- self.assertEqual(
675
- "baseline",
676
- git_output(allowed_remote, "show", "refs/heads/codex/RENAME-ALLOW:renamed.txt"),
677
- )
678
- self.assertNotEqual(
679
- 0,
680
- git(
681
- allowed_remote,
682
- "cat-file",
683
- "-e",
684
- "refs/heads/codex/RENAME-ALLOW:shared.txt",
685
- check=False,
686
- ).returncode,
687
- )
688
-
689
- def test_commit_push_stages_mixed_index_and_worktree_state(self) -> None:
690
- _, repo, remote = self.make_repo()
691
- worktree = self.start_task(repo, "MIXED-STAGE")
692
- (worktree / "shared.txt").write_text("staged-v1\n", encoding="utf-8")
693
- git(worktree, "add", "shared.txt")
694
- (worktree / "shared.txt").write_text("worktree-v2\n", encoding="utf-8")
695
- (worktree / "new-file.txt").write_text("new\n", encoding="utf-8")
696
-
697
- self.commit_push(worktree, "MIXED-STAGE", "MIXED-STAGE: commit final task state")
698
-
699
- ref = "refs/heads/codex/MIXED-STAGE"
700
- self.assertEqual("worktree-v2", git_output(remote, "show", f"{ref}:shared.txt"))
701
- self.assertEqual("new", git_output(remote, "show", f"{ref}:new-file.txt"))
702
-
703
- def test_final_gate_receipt_reuses_manual_pass_and_commit_retry(self) -> None:
704
- root, repo, remote = self.make_repo()
705
- gate_count = root / "gate-count"
706
- self.update_config(
707
- repo,
708
- lambda config: config["commands"].update(
709
- {"gate_changed": f"printf x >> {gate_count}"}
710
- ),
711
- )
712
- worktree = self.start_task(repo, "GATE-REUSE", "shared.txt")
713
- (worktree / "shared.txt").write_text("validated\n", encoding="utf-8")
714
- self.ap(worktree, "light-gate", "--scope", "changed")
715
- self.assertEqual("x", gate_count.read_text(encoding="utf-8"))
716
- self.approve_task(worktree, "GATE-REUSE")
717
- common_dir = Path(git_output(worktree, "rev-parse", "--git-common-dir"))
718
- if not common_dir.is_absolute():
719
- common_dir = (worktree / common_dir).resolve()
720
- fail_once = common_dir / "precommit-failed-once"
721
- self.install_hook(
722
- repo,
723
- "pre-commit",
724
- f'if [ ! -f "{fail_once}" ]; then touch "{fail_once}"; exit 1; fi\n',
725
- )
726
-
727
- first = self.ap(
728
- worktree,
729
- "commit-push",
730
- "GATE-REUSE",
731
- "--msg",
732
- "GATE-REUSE: validated change",
733
- check=False,
734
- )
735
- self.assertNotEqual(0, first.returncode)
736
- self.assertIn("REUSED", first.stdout + first.stderr)
737
- second = self.ap(
738
- worktree,
739
- "commit-push",
740
- "GATE-REUSE",
741
- "--msg",
742
- "GATE-REUSE: validated change",
743
- )
744
- self.assertIn("REUSED", second.stdout + second.stderr)
745
- self.assertEqual("x", gate_count.read_text(encoding="utf-8"))
746
- self.assertEqual(
747
- "validated",
748
- git_output(remote, "show", "refs/heads/codex/GATE-REUSE:shared.txt"),
749
- )
750
-
751
- def test_final_gate_receipt_invalidates_when_content_changes(self) -> None:
752
- root, repo, _ = self.make_repo()
753
- gate_count = root / "gate-count-invalidated"
754
- self.update_config(
755
- repo,
756
- lambda config: config["commands"].update(
757
- {"gate_changed": f"printf x >> {gate_count}"}
758
- ),
759
- )
760
- worktree = self.start_task(repo, "GATE-INVALIDATE", "shared.txt")
761
- (worktree / "shared.txt").write_text("first\n", encoding="utf-8")
762
- self.ap(worktree, "light-gate", "--scope", "changed")
763
- (worktree / "shared.txt").write_text("second\n", encoding="utf-8")
764
- self.approve_task(worktree, "GATE-INVALIDATE")
765
-
766
- result = self.ap(
767
- worktree,
768
- "commit-push",
769
- "GATE-INVALIDATE",
770
- "--msg",
771
- "GATE-INVALIDATE: use current content",
772
- )
773
-
774
- self.assertNotIn("REUSED", result.stdout + result.stderr)
775
- self.assertEqual("xx", gate_count.read_text(encoding="utf-8"))
776
-
777
- def test_task_scope_add_expands_direct_scope_idempotently(self) -> None:
778
- _, repo, remote = self.make_repo("adaptive", require_review=False)
779
- self.ap(
780
- repo,
781
- "task-start",
782
- "SCOPE-DIRECT",
783
- "--owned-path",
784
- "shared.txt",
785
- "--force-lifecycle",
786
- )
787
- expanded = self.ap(
788
- repo,
789
- "task-scope-add",
790
- "SCOPE-DIRECT",
791
- "--owned-path",
792
- "future.txt",
793
- "--json",
794
- )
795
- payload = json.loads(expanded.stdout)
796
- self.assertEqual("expanded", payload["status"])
797
- self.assertEqual(2, payload["scope_revision"])
798
- noop = json.loads(
799
- self.ap(
800
- repo,
801
- "task-scope-add",
802
- "SCOPE-DIRECT",
803
- "--owned-path",
804
- "future.txt",
805
- "--json",
806
- ).stdout
807
- )
808
- self.assertEqual("noop", noop["status"])
809
- self.assertEqual(2, noop["scope_revision"])
810
-
811
- (repo / "future.txt").write_text("future\n", encoding="utf-8")
812
- self.ap(
813
- repo,
814
- "commit-push",
815
- "SCOPE-DIRECT",
816
- "--msg",
817
- "SCOPE-DIRECT: add future file",
818
- )
819
- self.assertEqual("future", git_output(remote, "show", "refs/heads/dev:future.txt"))
820
-
821
- def test_task_scope_add_invalidates_review_and_blocks_conflicts(self) -> None:
822
- _, repo, _ = self.make_repo()
823
- first = self.start_task(repo, "SCOPE-FIRST", "shared.txt")
824
- self.start_task(repo, "SCOPE-SECOND", "second-owned.txt")
825
- (first / "shared.txt").write_text("reviewed\n", encoding="utf-8")
826
- old_fingerprint = self.approve_task(first, "SCOPE-FIRST")
827
-
828
- expanded = json.loads(
829
- self.ap(
830
- first,
831
- "task-scope-add",
832
- "SCOPE-FIRST",
833
- "--owned-path",
834
- "future.txt",
835
- "--json",
836
- ).stdout
837
- )
838
- self.assertEqual(2, expanded["scope_revision"])
839
- status = json.loads(self.ap(first, "task-status", "SCOPE-FIRST", "--json").stdout)["tasks"][0]
840
- self.assertEqual("pending", status["review"]["verdict"])
841
- self.assertNotEqual(old_fingerprint, status["current_diff_fingerprint"])
842
- stale = self.ap(
843
- first,
844
- "task-review",
845
- "SCOPE-FIRST",
846
- "--verdict",
847
- "approved",
848
- "--diff-fingerprint",
849
- old_fingerprint,
850
- "--reviewer",
851
- "test-reviewer",
852
- check=False,
853
- )
854
- self.assertNotEqual(0, stale.returncode)
855
-
856
- conflict = self.ap(
857
- first,
858
- "task-scope-add",
859
- "SCOPE-FIRST",
860
- "--owned-path",
861
- "second-owned.txt",
862
- check=False,
863
- )
864
- self.assertNotEqual(0, conflict.returncode)
865
- self.assertIn("SCOPE-SECOND", conflict.stdout + conflict.stderr)
866
-
867
- def test_task_scope_add_escalates_risk_without_moving_worktrees(self) -> None:
868
- _, repo, _ = self.make_repo("adaptive", require_review=False)
869
- self.ap(
870
- repo,
871
- "task-start",
872
- "SCOPE-RISK",
873
- "--owned-path",
874
- "shared.txt",
875
- "--force-lifecycle",
876
- )
877
- before = git_output(repo, "worktree", "list", "--porcelain")
878
- expanded = json.loads(
879
- self.ap(
880
- repo,
881
- "task-scope-add",
882
- "SCOPE-RISK",
883
- "--owned-path",
884
- "backend/auth/token.go",
885
- "--json",
886
- ).stdout
887
- )
888
- self.assertEqual("high-risk", expanded["effective_profile"])
889
- self.assertTrue(expanded["review_required"])
890
- self.assertEqual(before, git_output(repo, "worktree", "list", "--porcelain"))
891
-
892
- def test_unnecessary_lifecycle_rejects_before_access_or_fetch_checks(self) -> None:
893
- _, repo, _ = self.make_repo("adaptive", require_review=False)
894
- engineering = repo / "docs" / "ENGINEERING.md"
895
- text = engineering.read_text(encoding="utf-8")
896
- engineering.write_text(text.replace("front-pass", "CHANGE_ME", 1), encoding="utf-8")
897
- git(repo, "add", "docs/ENGINEERING.md")
898
- git(repo, "commit", "-qm", "invalidate access for preflight test")
899
- git(repo, "push", "-q", "origin", "dev")
900
-
901
- result = self.ap(
902
- repo,
903
- "task-start",
904
- "DIRECT-PREFLIGHT",
905
- "--base",
906
- "origin/branch-that-must-not-be-fetched",
907
- "--owned-path",
908
- "shared.txt",
909
- check=False,
910
- )
911
- output = result.stdout + result.stderr
912
- self.assertNotEqual(0, result.returncode)
913
- self.assertIn("does not need a machine task lifecycle", output)
914
- self.assertNotIn("initialization is incomplete", output)
915
-
916
- def test_continue_direct_can_adopt_owned_changes_for_new_review_lifecycle(self) -> None:
917
- root, repo, remote = self.make_repo("adaptive", require_review=False)
918
- claim = self.claim_direct(repo, "shared.txt")
919
- (repo / "shared.txt").write_text("continued direct\n", encoding="utf-8")
920
- started = self.ap(
921
- repo,
922
- "task-start",
923
- "DIRECT-CONTINUE",
924
- "--owned-path",
925
- "shared.txt",
926
- "--continue-direct",
927
- "--direct-claim",
928
- claim,
929
- "--review-required",
930
- )
931
- self.assertIn("execution_mode=direct", started.stdout)
932
- status = json.loads(
933
- self.ap(repo, "task-status", "DIRECT-CONTINUE", "--json").stdout
934
- )["tasks"][0]
935
- self.assertEqual("direct", status["execution_mode"])
936
- missing_reviewer = self.ap(
937
- repo,
938
- "task-review",
939
- "DIRECT-CONTINUE",
940
- "--verdict",
941
- "approved",
942
- "--diff-fingerprint",
943
- status["current_diff_fingerprint"],
944
- check=False,
945
- )
946
- self.assertNotEqual(0, missing_reviewer.returncode)
947
- self.assertIn("explicit --reviewer", missing_reviewer.stdout + missing_reviewer.stderr)
948
- runner = self.artifact_reviewer_runner(root, "continued direct")
949
- reviewed = json.loads(
950
- self.ap(
951
- repo,
952
- "review-run",
953
- "DIRECT-CONTINUE",
954
- "--reviewer",
955
- "direct-reviewer",
956
- "--runner-command-json",
957
- runner,
958
- "--json",
959
- ).stdout
960
- )
961
- self.assertEqual("approved", reviewed["verdict"])
962
- assignment_path = Path(
963
- json.loads(
964
- self.registry_manifest_path(repo, "DIRECT-CONTINUE").read_text(encoding="utf-8")
965
- )["review"]["assignment_path"]
966
- )
967
- pushed = self.ap(
968
- repo,
969
- "commit-push",
970
- "DIRECT-CONTINUE",
971
- "--msg",
972
- "DIRECT-CONTINUE: update",
973
- )
974
- self.assertIn("execution_mode=direct", pushed.stdout)
975
- self.assertEqual("continued direct", git_output(remote, "show", "refs/heads/dev:shared.txt"))
976
- self.assertFalse(assignment_path.parent.exists())
977
-
978
- claim = self.claim_direct(repo, "shared.txt")
979
- (repo / "shared.txt").write_text("owned again\n", encoding="utf-8")
980
- (repo / "unrelated.txt").write_text("unknown\n", encoding="utf-8")
981
- rejected = self.ap(
982
- repo,
983
- "task-start",
984
- "DIRECT-CONTINUE-BLOCKED",
985
- "--owned-path",
986
- "shared.txt",
987
- "--continue-direct",
988
- "--direct-claim",
989
- claim,
990
- "--review-required",
991
- check=False,
992
- )
993
- self.assertNotEqual(0, rejected.returncode)
994
- self.assertIn("unrelated.txt", rejected.stdout + rejected.stderr)
995
- self.assertFalse(self.registry_manifest_path(repo, "DIRECT-CONTINUE-BLOCKED").exists())
996
-
997
- def test_reviewer_cannot_be_current_writer(self) -> None:
998
- _, repo, _ = self.make_repo()
999
- self.ap(
1000
- repo,
1001
- "task-start",
1002
- "SELF-REVIEW",
1003
- "--base",
1004
- "origin/dev",
1005
- "--owned-path",
1006
- "src",
1007
- "--isolated",
1008
- "--review-required",
1009
- )
1010
- worktree = self.task_worktree(repo, "SELF-REVIEW")
1011
- payload = worktree / "src" / "payload.txt"
1012
- payload.parent.mkdir(parents=True, exist_ok=True)
1013
- payload.write_text("changed\n", encoding="utf-8")
1014
- self.ap(
1015
- repo,
1016
- "task-handoff",
1017
- "SELF-REVIEW",
1018
- "--from",
1019
- _TEST_OWNER,
1020
- "--to",
1021
- "self-reviewer",
1022
- "--generation",
1023
- "1",
1024
- )
1025
- status = json.loads(
1026
- self.ap(worktree, "task-status", "SELF-REVIEW", "--json").stdout
1027
- )["tasks"][0]
1028
- rejected = self.ap(
1029
- worktree,
1030
- "task-review",
1031
- "SELF-REVIEW",
1032
- "--verdict",
1033
- "approved",
1034
- "--diff-fingerprint",
1035
- status["current_diff_fingerprint"],
1036
- "--reviewer",
1037
- "self-reviewer",
1038
- check=False,
1039
- )
1040
- self.assertNotEqual(0, rejected.returncode)
1041
- self.assertIn("writer lease holder", rejected.stdout + rejected.stderr)
1042
-
1043
- def test_review_assignment_is_deadline_bound_and_idempotent(self) -> None:
1044
- _, repo, _ = self.make_repo()
1045
- worktree = self.start_task(repo, "REVIEW-DEADLINE", "shared.txt")
1046
- (worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
1047
-
1048
- first = json.loads(
1049
- self.ap(
1050
- worktree,
1051
- "review-assignment",
1052
- "REVIEW-DEADLINE",
1053
- "--reviewer",
1054
- "reviewer-1",
1055
- "--json",
1056
- ).stdout
1057
- )
1058
- second = json.loads(
1059
- self.ap(
1060
- worktree,
1061
- "review-assignment",
1062
- "REVIEW-DEADLINE",
1063
- "--reviewer",
1064
- "reviewer-1",
1065
- "--json",
1066
- ).stdout
1067
- )
1068
- self.assertEqual(first, second)
1069
- assignment = first["assignment"]
1070
- self.assertEqual("focused", assignment["review_depth"])
1071
- self.assertEqual(150, assignment["timeout_seconds"])
1072
- self.assertEqual(1, assignment["scope_revision"])
1073
- self.assertTrue(Path(first["assignment_path"]).is_file())
1074
- assignment_path = Path(first["assignment_path"])
1075
- artifact_path = Path(assignment["diff_artifact_path"])
1076
- artifact = artifact_path.read_bytes()
1077
- self.assertEqual(assignment_path.parent, artifact_path.parent)
1078
- self.assertEqual(0o600, assignment_path.stat().st_mode & 0o777)
1079
- self.assertEqual(0o600, artifact_path.stat().st_mode & 0o777)
1080
- self.assertEqual(hashlib.sha256(artifact).hexdigest(), assignment["diff_artifact_sha256"])
1081
- self.assertEqual("git-binary-patch-v1", assignment["diff_artifact_format"])
1082
- self.assertIn(b"review me", artifact)
1083
- emitted = self.ap(
1084
- worktree,
1085
- "review-artifact",
1086
- "--file",
1087
- str(assignment_path),
1088
- )
1089
- self.assertEqual(artifact, emitted.stdout.encode("utf-8"))
1090
- issued = datetime.fromisoformat(assignment["issued_at"])
1091
- deadline = datetime.fromisoformat(assignment["deadline_at"])
1092
- self.assertEqual(150, int((deadline - issued).total_seconds()))
1093
-
1094
- artifact_path.write_bytes(artifact + b"tampered\n")
1095
- tampered = self.ap(
1096
- worktree,
1097
- "review-assignment",
1098
- "REVIEW-DEADLINE",
1099
- "--reviewer",
1100
- "reviewer-1",
1101
- check=False,
1102
- )
1103
- self.assertNotEqual(0, tampered.returncode)
1104
- self.assertIn("SHA-256 mismatch", tampered.stdout + tampered.stderr)
1105
-
1106
- def test_review_assignment_hash_binding_rejects_assignment_file_tampering(self) -> None:
1107
- _, repo, _ = self.make_repo()
1108
- worktree = self.start_task(repo, "REVIEW-ASSIGNMENT-HASH", "shared.txt")
1109
- (worktree / "shared.txt").write_text("hash-bound review\n", encoding="utf-8")
1110
- issued = json.loads(
1111
- self.ap(
1112
- worktree,
1113
- "review-assignment",
1114
- "REVIEW-ASSIGNMENT-HASH",
1115
- "--reviewer",
1116
- "reviewer-hash",
1117
- "--json",
1118
- ).stdout
1119
- )
1120
- assignment_path = Path(issued["assignment_path"])
1121
- original = assignment_path.read_bytes()
1122
- manifest = json.loads(
1123
- self.registry_manifest_path(repo, "REVIEW-ASSIGNMENT-HASH").read_text(
1124
- encoding="utf-8"
1125
- )
1126
- )
1127
- self.assertEqual(
1128
- hashlib.sha256(original).hexdigest(),
1129
- manifest["review"]["assignment_sha256"],
1130
- )
1131
-
1132
- assignment_path.write_bytes(original + b" \n")
1133
- rejected = self.ap(
1134
- worktree,
1135
- "review-assignment",
1136
- "REVIEW-ASSIGNMENT-HASH",
1137
- "--reviewer",
1138
- "reviewer-hash",
1139
- check=False,
1140
- )
1141
- self.assertNotEqual(0, rejected.returncode)
1142
- self.assertIn("assignment SHA-256 mismatch", rejected.stdout + rejected.stderr)
1143
-
1144
- def test_review_assignment_rejects_symlinked_review_root(self) -> None:
1145
- root, repo, _ = self.make_repo()
1146
- worktree = self.start_task(repo, "REVIEW-SYMLINK", "shared.txt")
1147
- (worktree / "shared.txt").write_text("must stay git local\n", encoding="utf-8")
1148
- review_root = self.registry_manifest_path(repo, "REVIEW-SYMLINK").parent.parent / "reviews"
1149
- task_review_dir = review_root / "REVIEW-SYMLINK"
1150
- if task_review_dir.exists():
1151
- task_review_dir.rmdir()
1152
- if review_root.exists():
1153
- review_root.rmdir()
1154
- outside = root / "outside-reviews"
1155
- outside.mkdir()
1156
- review_root.symlink_to(outside, target_is_directory=True)
1157
-
1158
- rejected = self.ap(
1159
- worktree,
1160
- "review-assignment",
1161
- "REVIEW-SYMLINK",
1162
- "--reviewer",
1163
- "reviewer-symlink",
1164
- check=False,
1165
- )
1166
- self.assertNotEqual(0, rejected.returncode)
1167
- self.assertIn("symlinked Git-local review storage", rejected.stdout + rejected.stderr)
1168
- self.assertFalse((outside / "REVIEW-SYMLINK").exists())
1169
-
1170
- def test_review_snapshot_covers_git_states_without_mutating_main_index_or_objects(self) -> None:
1171
- _, repo, _ = self.make_repo()
1172
- (repo / "delete-me.txt").write_text("delete me\n", encoding="utf-8")
1173
- git(repo, "add", "delete-me.txt")
1174
- git(repo, "commit", "-qm", "add deletion fixture")
1175
- git(repo, "push", "-q", "origin", "dev")
1176
- worktree = self.start_task(repo, "REVIEW-GIT-STATES", ".")
1177
- (worktree / "delete-me.txt").unlink()
1178
- shared = worktree / "shared.txt"
1179
- shared.write_text("executable review\n", encoding="utf-8")
1180
- shared.chmod(shared.stat().st_mode | 0o111)
1181
- (worktree / "binary-review.bin").write_bytes(b"\x00\x01binary-review\xff" * 32)
1182
- (worktree / "review-link").symlink_to("shared.txt")
1183
- index_path = Path(git_output(worktree, "rev-parse", "--git-path", "index"))
1184
- if not index_path.is_absolute():
1185
- index_path = (worktree / index_path).resolve()
1186
- index_before = index_path.read_bytes()
1187
- objects_before = git_output(worktree, "count-objects", "-v")
1188
-
1189
- issued = json.loads(
1190
- self.ap(
1191
- worktree,
1192
- "review-assignment",
1193
- "REVIEW-GIT-STATES",
1194
- "--reviewer",
1195
- "reviewer-git-states",
1196
- "--json",
1197
- ).stdout
1198
- )
1199
- patch = Path(issued["assignment"]["diff_artifact_path"]).read_bytes()
1200
- self.assertIn(b"deleted file mode 100644", patch)
1201
- self.assertIn(b"old mode 100644", patch)
1202
- self.assertIn(b"new mode 100755", patch)
1203
- self.assertIn(b"new file mode 120000", patch)
1204
- self.assertIn(b"GIT binary patch", patch)
1205
- self.assertEqual(index_before, index_path.read_bytes())
1206
- self.assertEqual(objects_before, git_output(worktree, "count-objects", "-v"))
1207
- self.assertFalse(list(Path(issued["assignment_path"]).parent.glob(".snapshot-*")))
1208
-
1209
- def test_review_snapshot_stops_and_cleans_when_stream_limit_is_exceeded(self) -> None:
1210
- _, repo, _ = self.make_repo()
1211
- worktree = self.start_task(repo, "REVIEW-SIZE-LIMIT", "shared.txt")
1212
- # The input itself stays below the test limit while the Git patch
1213
- # headers plus body exceed it, exercising the streaming PIPE cutoff.
1214
- (worktree / "shared.txt").write_text("small\n", encoding="utf-8")
1215
- previous = os.environ.get("AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES")
1216
- os.environ["AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES"] = "128"
1217
- try:
1218
- rejected = self.ap(
1219
- worktree,
1220
- "review-assignment",
1221
- "REVIEW-SIZE-LIMIT",
1222
- "--reviewer",
1223
- "reviewer-size",
1224
- check=False,
1225
- )
1226
- finally:
1227
- if previous is None:
1228
- os.environ.pop("AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES", None)
1229
- else:
1230
- os.environ["AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES"] = previous
1231
- self.assertNotEqual(0, rejected.returncode)
1232
- self.assertIn("safety limit", rejected.stdout + rejected.stderr)
1233
- review_dir = (
1234
- self.registry_manifest_path(repo, "REVIEW-SIZE-LIMIT").parent.parent
1235
- / "reviews"
1236
- / "REVIEW-SIZE-LIMIT"
1237
- )
1238
- self.assertFalse(list(review_dir.glob(".snapshot-*")))
1239
- self.assertFalse(list(review_dir.glob("*.assignment.json")))
1240
- self.assertFalse(list(review_dir.glob("*.patch")))
1241
-
1242
- def test_review_snapshot_rejects_oversized_input_before_creating_temp_objects(self) -> None:
1243
- _, repo, _ = self.make_repo()
1244
- worktree = self.start_task(repo, "REVIEW-INPUT-LIMIT", "shared.txt")
1245
- (worktree / "shared.txt").write_text("x" * 4096 + "\n", encoding="utf-8")
1246
- objects_before = git_output(worktree, "count-objects", "-v")
1247
- previous = os.environ.get("AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES")
1248
- os.environ["AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES"] = "128"
1249
- try:
1250
- rejected = self.ap(
1251
- worktree,
1252
- "review-assignment",
1253
- "REVIEW-INPUT-LIMIT",
1254
- "--reviewer",
1255
- "reviewer-input-size",
1256
- check=False,
1257
- )
1258
- finally:
1259
- if previous is None:
1260
- os.environ.pop("AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES", None)
1261
- else:
1262
- os.environ["AUTOCODING_REVIEW_ARTIFACT_MAX_BYTES"] = previous
1263
- self.assertNotEqual(0, rejected.returncode)
1264
- self.assertIn("snapshot input exceeds", rejected.stdout + rejected.stderr)
1265
- review_dir = (
1266
- self.registry_manifest_path(repo, "REVIEW-INPUT-LIMIT").parent.parent
1267
- / "reviews"
1268
- / "REVIEW-INPUT-LIMIT"
1269
- )
1270
- self.assertFalse(review_dir.exists())
1271
- self.assertEqual(objects_before, git_output(worktree, "count-objects", "-v"))
1272
-
1273
- def test_review_run_supervises_separate_process_and_records_result_once(self) -> None:
1274
- root, repo, _ = self.make_repo()
1275
- worktree = self.start_task(repo, "REVIEW-RUN", ".")
1276
- (worktree / "shared.txt").write_text("staged tracked review token\n", encoding="utf-8")
1277
- git(worktree, "add", "shared.txt")
1278
- (worktree / "untracked-review.txt").write_text(
1279
- "untracked review token\n",
1280
- encoding="utf-8",
1281
- )
1282
- runner = self.artifact_reviewer_runner(
1283
- root,
1284
- "staged tracked review token",
1285
- "untracked review token",
1286
- )
1287
- completed = self.ap(
1288
- worktree,
1289
- "review-run",
1290
- "REVIEW-RUN",
1291
- "--reviewer",
1292
- "reviewer-runtime",
1293
- "--runner-command-json",
1294
- runner,
1295
- "--json",
1296
- )
1297
- result = json.loads(completed.stdout)
1298
- self.assertEqual("approved", result["verdict"])
1299
- self.assertEqual("artifact reviewed", result["summary"])
1300
-
1301
- status = json.loads(
1302
- self.ap(worktree, "task-status", "REVIEW-RUN", "--json").stdout
1303
- )["tasks"][0]
1304
- review = status["review"]
1305
- self.assertEqual("approved", review["verdict"])
1306
- self.assertEqual("completed", review["runtime_state"])
1307
- self.assertEqual("reviewer-runtime", review["reviewer"])
1308
- self.assertEqual(0, review["runtime_exit_code"])
1309
- result_path = Path(review["runtime_result_path"])
1310
- receipt_path = Path(review["runtime_receipt_path"])
1311
- self.assertEqual(0o600, result_path.stat().st_mode & 0o777)
1312
- self.assertEqual(0o600, receipt_path.stat().st_mode & 0o777)
1313
- receipt = json.loads(receipt_path.read_text())
1314
- self.assertEqual("completed", receipt["status"])
1315
- self.assertRegex(receipt["result_sha256"], r"^[0-9a-f]{64}$")
1316
-
1317
- repeated = self.ap(
1318
- worktree,
1319
- "review-run",
1320
- "REVIEW-RUN",
1321
- "--reviewer",
1322
- "reviewer-runtime",
1323
- "--runner-command-json",
1324
- runner,
1325
- check=False,
1326
- )
1327
- self.assertNotEqual(0, repeated.returncode)
1328
- self.assertIn("already complete", repeated.stdout + repeated.stderr)
1329
-
1330
- tampered_payload = json.loads(result_path.read_text())
1331
- tampered_payload["summary"] = "tampered after review"
1332
- result_path.write_text(json.dumps(tampered_payload) + "\n", encoding="utf-8")
1333
- tampered = self.ap(
1334
- worktree,
1335
- "task-review",
1336
- "REVIEW-RUN",
1337
- "--verdict",
1338
- "approved",
1339
- "--diff-fingerprint",
1340
- status["current_diff_fingerprint"],
1341
- "--reviewer",
1342
- "reviewer-runtime",
1343
- check=False,
1344
- )
1345
- self.assertNotEqual(0, tampered.returncode)
1346
- self.assertIn("result changed", tampered.stdout + tampered.stderr)
1347
-
1348
- def test_review_run_retries_clean_exit_without_event_and_rejects_approved_file(self) -> None:
1349
- root, repo, _ = self.make_repo()
1350
- worktree = self.start_task(repo, "REVIEW-NO-EVENT", "shared.txt")
1351
- (worktree / "shared.txt").write_text("review without event\n", encoding="utf-8")
1352
- counter = root / "attempt-count.txt"
1353
- runner_path = root / "no-event-reviewer.py"
1354
- runner_path.write_text(
1355
- "import json, os\n"
1356
- "from pathlib import Path\n"
1357
- f"counter = Path({str(counter)!r})\n"
1358
- "counter.write_text(str(int(counter.read_text() or '0') + 1) if counter.exists() else '1')\n"
1359
- "Path(os.environ['AUTOCODING_REVIEW_RESULT']).write_text(json.dumps({'verdict': 'approved'}) + '\\n')\n",
1360
- encoding="utf-8",
1361
- )
1362
- rejected = self.ap(
1363
- worktree,
1364
- "review-run",
1365
- "REVIEW-NO-EVENT",
1366
- "--reviewer",
1367
- "reviewer-no-event",
1368
- "--runner-command-json",
1369
- json.dumps([sys.executable, str(runner_path)]),
1370
- check=False,
1371
- )
1372
- self.assertNotEqual(0, rejected.returncode)
1373
- self.assertIn("runtime-unavailable", rejected.stdout + rejected.stderr)
1374
- self.assertEqual("2", counter.read_text())
1375
- status = json.loads(
1376
- self.ap(worktree, "task-status", "REVIEW-NO-EVENT", "--json").stdout
1377
- )["tasks"][0]
1378
- self.assertEqual("runtime-unavailable", status["review"]["runtime_state"])
1379
- self.assertEqual("blocked", status["review"]["verdict"])
1380
-
1381
- def test_substantive_result_written_before_timeout_cannot_be_bypassed(self) -> None:
1382
- root, repo, _ = self.make_repo()
1383
- worktree = self.start_task(repo, "REVIEW-SUBSTANTIVE", "shared.txt")
1384
- (worktree / "shared.txt").write_text("substantive finding\n", encoding="utf-8")
1385
- issued = json.loads(
1386
- self.ap(
1387
- worktree,
1388
- "review-assignment",
1389
- "REVIEW-SUBSTANTIVE",
1390
- "--reviewer",
1391
- "reviewer-substantive",
1392
- "--json",
1393
- ).stdout
1394
- )
1395
- self.shorten_review_deadline(repo, "REVIEW-SUBSTANTIVE", issued)
1396
- runner_path = root / "substantive-reviewer.py"
1397
- runner_path.write_text(
1398
- "import json, os, time\n"
1399
- "from pathlib import Path\n"
1400
- "result = Path(os.environ['AUTOCODING_REVIEW_RESULT'])\n"
1401
- "result.write_text(json.dumps({'verdict': 'changes-requested', 'summary': 'real defect'}) + '\\n')\n"
1402
- "result.chmod(0o600)\n"
1403
- "print(json.dumps({'type': 'turn.started'}), flush=True)\n"
1404
- "time.sleep(30)\n",
1405
- encoding="utf-8",
1406
- )
1407
- timed_out = self.ap(
1408
- worktree,
1409
- "review-run",
1410
- "REVIEW-SUBSTANTIVE",
1411
- "--reviewer",
1412
- "reviewer-substantive",
1413
- "--runner-command-json",
1414
- json.dumps([sys.executable, str(runner_path)]),
1415
- check=False,
1416
- )
1417
- self.assertNotEqual(0, timed_out.returncode)
1418
- self.assertIn("cannot be bypassed", timed_out.stdout + timed_out.stderr)
1419
- status = json.loads(
1420
- self.ap(worktree, "task-status", "REVIEW-SUBSTANTIVE", "--json").stdout
1421
- )["tasks"][0]
1422
- review = status["review"]
1423
- self.assertEqual("changes-requested", review["verdict"])
1424
- self.assertEqual("blocked", review["runtime_state"])
1425
- receipt = json.loads(Path(review["runtime_receipt_path"]).read_text())
1426
- self.assertEqual("blocked", receipt["status"])
1427
- self.assertEqual("changes-requested", receipt["verdict"])
1428
- self.assertEqual(1, len(receipt["attempts"]))
1429
- bypass = self.ap(
1430
- worktree,
1431
- "review-runtime-override",
1432
- "REVIEW-SUBSTANTIVE",
1433
- "--diff-fingerprint",
1434
- status["current_diff_fingerprint"],
1435
- "--authorized-by",
1436
- "product-owner",
1437
- "--authorization-ref",
1438
- "conversation-substantive",
1439
- "--reason",
1440
- "A substantive Reviewer result must remain blocking.",
1441
- "--evidence",
1442
- "reviewer returned changes requested",
1443
- "--confirm-runtime-bypass",
1444
- check=False,
1445
- )
1446
- self.assertNotEqual(0, bypass.returncode)
1447
- self.assertIn("allowed only after", bypass.stdout + bypass.stderr)
1448
-
1449
- def test_substantive_result_survives_nonzero_reviewer_exit(self) -> None:
1450
- root, repo, _ = self.make_repo()
1451
- worktree = self.start_task(repo, "REVIEW-NONZERO", "shared.txt")
1452
- (worktree / "shared.txt").write_text("nonzero substantive finding\n", encoding="utf-8")
1453
- runner_path = root / "nonzero-substantive-reviewer.py"
1454
- runner_path.write_text(
1455
- "import json, os\n"
1456
- "from pathlib import Path\n"
1457
- "result = Path(os.environ['AUTOCODING_REVIEW_RESULT'])\n"
1458
- "result.write_text(json.dumps({'verdict': 'changes-requested', 'summary': 'specific defect'}) + '\\n')\n"
1459
- "result.chmod(0o600)\n"
1460
- "print(json.dumps({'type': 'turn.started'}), flush=True)\n"
1461
- "raise SystemExit(7)\n",
1462
- encoding="utf-8",
1463
- )
1464
- rejected = self.ap(
1465
- worktree,
1466
- "review-run",
1467
- "REVIEW-NONZERO",
1468
- "--reviewer",
1469
- "reviewer-nonzero",
1470
- "--runner-command-json",
1471
- json.dumps([sys.executable, str(runner_path)]),
1472
- check=False,
1473
- )
1474
- self.assertNotEqual(0, rejected.returncode)
1475
- self.assertIn("cannot be bypassed", rejected.stdout + rejected.stderr)
1476
- status = json.loads(
1477
- self.ap(worktree, "task-status", "REVIEW-NONZERO", "--json").stdout
1478
- )["tasks"][0]
1479
- review = status["review"]
1480
- self.assertEqual("changes-requested", review["verdict"])
1481
- self.assertEqual("blocked", review["runtime_state"])
1482
- self.assertEqual(7, review["runtime_exit_code"])
1483
- result = json.loads(Path(review["runtime_result_path"]).read_text())
1484
- self.assertEqual("specific defect", result["summary"])
1485
- receipt = json.loads(Path(review["runtime_receipt_path"]).read_text())
1486
- self.assertEqual("blocked", receipt["status"])
1487
- self.assertEqual("changes-requested", receipt["verdict"])
1488
- self.assertEqual(7, receipt["exit_code"])
1489
-
1490
- def test_substantive_agent_message_before_timeout_cannot_be_bypassed(self) -> None:
1491
- root, repo, _ = self.make_repo()
1492
- worktree = self.start_task(repo, "REVIEW-EVENT-FINDING", "shared.txt")
1493
- (worktree / "shared.txt").write_text("event finding\n", encoding="utf-8")
1494
- issued = json.loads(
1495
- self.ap(
1496
- worktree,
1497
- "review-assignment",
1498
- "REVIEW-EVENT-FINDING",
1499
- "--reviewer",
1500
- "reviewer-event-finding",
1501
- "--json",
1502
- ).stdout
1503
- )
1504
- self.shorten_review_deadline(repo, "REVIEW-EVENT-FINDING", issued)
1505
- runner_path = root / "event-finding-reviewer.py"
1506
- runner_path.write_text(
1507
- "import json, sys, time\n"
1508
- "result = json.dumps({'verdict': 'blocked', 'summary': 'event-only defect'})\n"
1509
- "print(json.dumps({'type': 'turn.started'}), flush=True)\n"
1510
- "sys.stdout.write(json.dumps({'type': 'item.completed', 'item': {'type': 'agent_message', 'text': result}}))\n"
1511
- "sys.stdout.flush()\n"
1512
- "time.sleep(30)\n",
1513
- encoding="utf-8",
1514
- )
1515
- timed_out = self.ap(
1516
- worktree,
1517
- "review-run",
1518
- "REVIEW-EVENT-FINDING",
1519
- "--reviewer",
1520
- "reviewer-event-finding",
1521
- "--runner-command-json",
1522
- json.dumps([sys.executable, str(runner_path)]),
1523
- check=False,
1524
- )
1525
- self.assertNotEqual(0, timed_out.returncode)
1526
- self.assertIn("cannot be bypassed", timed_out.stdout + timed_out.stderr)
1527
- status = json.loads(
1528
- self.ap(worktree, "task-status", "REVIEW-EVENT-FINDING", "--json").stdout
1529
- )["tasks"][0]
1530
- self.assertEqual("blocked", status["review"]["verdict"])
1531
- self.assertEqual("blocked", status["review"]["runtime_state"])
1532
- result = json.loads(Path(status["review"]["runtime_result_path"]).read_text())
1533
- self.assertEqual("event-only defect", result["summary"])
1534
-
1535
- def test_blocked_runtime_cannot_be_reassigned_or_overwritten_as_approved(self) -> None:
1536
- root, repo, _ = self.make_repo()
1537
- worktree = self.start_task(repo, "REVIEW-BLOCKED", "shared.txt")
1538
- (worktree / "shared.txt").write_text("review is blocked\n", encoding="utf-8")
1539
- blocked_reviewer = root / "blocked-reviewer.py"
1540
- blocked_reviewer.write_text(
1541
- "import json\n"
1542
- "print(json.dumps({'verdict': 'blocked', 'summary': 'missing evidence'}))\n",
1543
- encoding="utf-8",
1544
- )
1545
- runner = json.dumps([sys.executable, str(blocked_reviewer)])
1546
- blocked = self.ap(
1547
- worktree,
1548
- "review-run",
1549
- "REVIEW-BLOCKED",
1550
- "--reviewer",
1551
- "reviewer-blocked",
1552
- "--runner-command-json",
1553
- runner,
1554
- check=False,
1555
- )
1556
- self.assertNotEqual(0, blocked.returncode)
1557
- self.assertIn("Reviewer returned blocked", blocked.stdout + blocked.stderr)
1558
- status = json.loads(
1559
- self.ap(worktree, "task-status", "REVIEW-BLOCKED", "--json").stdout
1560
- )["tasks"][0]
1561
- self.assertEqual("blocked", status["review"]["verdict"])
1562
- self.assertEqual("blocked", status["review"]["runtime_state"])
1563
-
1564
- reassigned = self.ap(
1565
- worktree,
1566
- "review-assignment",
1567
- "REVIEW-BLOCKED",
1568
- "--reviewer",
1569
- "reviewer-blocked",
1570
- check=False,
1571
- )
1572
- self.assertNotEqual(0, reassigned.returncode)
1573
- self.assertIn("already complete or consumed", reassigned.stdout + reassigned.stderr)
1574
- overwritten = self.ap(
1575
- worktree,
1576
- "task-review",
1577
- "REVIEW-BLOCKED",
1578
- "--verdict",
1579
- "approved",
1580
- "--diff-fingerprint",
1581
- status["current_diff_fingerprint"],
1582
- "--reviewer",
1583
- "reviewer-blocked",
1584
- check=False,
1585
- )
1586
- self.assertNotEqual(0, overwritten.returncode)
1587
- self.assertIn("runtime state=blocked", overwritten.stdout + overwritten.stderr)
1588
- bypass = self.ap(
1589
- worktree,
1590
- "review-runtime-override",
1591
- "REVIEW-BLOCKED",
1592
- "--diff-fingerprint",
1593
- status["current_diff_fingerprint"],
1594
- "--authorized-by",
1595
- "product-owner",
1596
- "--authorization-ref",
1597
- "conversation-blocked",
1598
- "--reason",
1599
- "User cannot override a substantive Reviewer blocked verdict.",
1600
- "--evidence",
1601
- "reviewer returned blocked",
1602
- "--confirm-runtime-bypass",
1603
- check=False,
1604
- )
1605
- self.assertNotEqual(0, bypass.returncode)
1606
- self.assertIn("allowed only after", bypass.stdout + bypass.stderr)
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.7", 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.7.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.7", 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_fixed_runtime_repair(self) -> None:
1728
- root, repo, _ = self.make_repo()
1729
- managed_434 = self.managed_runtime(root / "runtime-434", "4.3.4")
1730
- managed_fixed = self.managed_runtime(root / "runtime-fixed", "4.3.6")
1731
- managed_final = self.managed_runtime(root / "runtime-final", "4.3.7")
1732
- worktree = self.start_task(repo, "REVIEW-RETRY-REPAIR", "shared.txt")
1733
- (worktree / "shared.txt").write_text("repair retry payload\n", encoding="utf-8")
1734
- common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
1735
- if not common_dir.is_absolute():
1736
- common_dir = (repo / common_dir).resolve()
1737
- state_root = common_dir / "auto-coding-skill"
1738
- blocked_reviewer = root / "repair-artifact-access-block.py"
1739
- blocked_reviewer.write_text(
1740
- "import json\n"
1741
- f"state_root = {str(state_root)!r}\n"
1742
- "print(json.dumps({"
1743
- "'verdict': 'blocked', "
1744
- "'summary': 'Review could not begin because review-artifact failed to verify and emit the immutable patch.', "
1745
- "'evidence': ['review-artifact exited with: Cannot protect Git-local review storage: ' + state_root + ': [Errno 1] Operation not permitted'], "
1746
- "'risks': ['The SHA-256-bound frozen diff was not emitted or reviewed, so no substantive correctness or security conclusion is available.']}))\n",
1747
- encoding="utf-8",
1748
- )
1749
- blocked_runner = json.dumps([sys.executable, str(blocked_reviewer)])
1750
- issued = json.loads(
1751
- self.ap(
1752
- worktree,
1753
- "review-assignment",
1754
- "REVIEW-RETRY-REPAIR",
1755
- "--reviewer",
1756
- "repair-reviewer",
1757
- "--json",
1758
- ).stdout
1759
- )
1760
- self.shorten_review_deadline(
1761
- repo,
1762
- "REVIEW-RETRY-REPAIR",
1763
- issued,
1764
- seconds=30,
1765
- )
1766
- self.ap(
1767
- worktree,
1768
- "review-run",
1769
- "REVIEW-RETRY-REPAIR",
1770
- "--reviewer",
1771
- "repair-reviewer",
1772
- "--runner-command-json",
1773
- blocked_runner,
1774
- check=False,
1775
- )
1776
- manifest_path = self.registry_manifest_path(repo, "REVIEW-RETRY-REPAIR")
1777
- manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
1778
- manifest["skill_version"] = "4.3.2"
1779
- manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
1780
- fingerprint = manifest["review"]["diff_fingerprint"]
1781
- first_retry = json.loads(
1782
- self.ap_script(
1783
- worktree,
1784
- managed_434,
1785
- "review-runtime-retry",
1786
- "REVIEW-RETRY-REPAIR",
1787
- "--diff-fingerprint",
1788
- fingerprint,
1789
- "--reason-code",
1790
- "managed-review-artifact-access",
1791
- "--confirm-managed-runtime-retry",
1792
- "--json",
1793
- ).stdout
1794
- )
1795
- self.assertEqual("retry-v4.3.4", first_retry["retry_token"])
1796
- self.ap_script(
1797
- worktree,
1798
- managed_434,
1799
- "review-run",
1800
- "REVIEW-RETRY-REPAIR",
1801
- "--reviewer",
1802
- "repair-reviewer",
1803
- "--runner-command-json",
1804
- blocked_runner,
1805
- check=False,
1806
- )
1807
- blocked_status = json.loads(
1808
- self.ap_script(
1809
- worktree,
1810
- managed_434,
1811
- "task-status",
1812
- "REVIEW-RETRY-REPAIR",
1813
- "--json",
1814
- ).stdout
1815
- )["tasks"][0]
1816
- old_review = blocked_status["review"]
1817
- old_evidence_paths = [
1818
- Path(old_review["runtime_retry_audit_path"]),
1819
- Path(old_review["runtime_result_path"]),
1820
- Path(old_review["runtime_receipt_path"]),
1821
- Path(old_review["runtime_event_log_path"]),
1822
- ]
1823
- old_evidence = {path: path.read_bytes() for path in old_evidence_paths}
1824
-
1825
- repaired = json.loads(
1826
- self.ap_script(
1827
- worktree,
1828
- managed_fixed,
1829
- "review-runtime-retry",
1830
- "REVIEW-RETRY-REPAIR",
1831
- "--diff-fingerprint",
1832
- fingerprint,
1833
- "--reason-code",
1834
- "managed-review-artifact-access",
1835
- "--confirm-managed-runtime-retry",
1836
- "--json",
1837
- ).stdout
1838
- )
1839
- self.assertEqual("retry-v4.3.6", repaired["retry_token"])
1840
- repair_audit = json.loads(Path(repaired["audit_path"]).read_text(encoding="utf-8"))
1841
- self.assertEqual("retry-v4.3.4", repair_audit["superseded_retry_token"])
1842
- self.assertEqual("blocked", repair_audit["superseded_retry_state"])
1843
- assignment = json.loads(
1844
- Path(old_review["assignment_path"]).read_text(encoding="utf-8")
1845
- )
1846
- observed = (
1847
- datetime.fromisoformat(assignment["deadline_at"]) + timedelta(seconds=1)
1848
- ).isoformat()
1849
- deadline_reviewer = root / "stale-deadline-block.py"
1850
- deadline_reviewer.write_text(
1851
- "import json\n"
1852
- "print(json.dumps({"
1853
- "'verdict': 'blocked', "
1854
- "'summary': 'The immutable artifact passed mode-0600 and SHA-256 verification, but the assignment deadline expired before the deep review could be completed.', "
1855
- f"'evidence': ['review-artifact completed successfully for diff_artifact_sha256 {assignment['diff_artifact_sha256']}.', "
1856
- f"'Assignment deadline_at was {assignment['deadline_at']}; observed UTC time before completion was {observed}.'], "
1857
- "'risks': ['The 1701-line cross-module patch did not receive a complete substantive deep review within its bound deadline; no approval should be inferred.']}))\n",
1858
- encoding="utf-8",
1859
- )
1860
- self.ap_script(
1861
- worktree,
1862
- managed_fixed,
1863
- "review-run",
1864
- "REVIEW-RETRY-REPAIR",
1865
- "--reviewer",
1866
- "repair-reviewer",
1867
- "--runner-command-json",
1868
- json.dumps([sys.executable, str(deadline_reviewer)]),
1869
- check=False,
1870
- )
1871
- deadline_status = json.loads(
1872
- self.ap_script(
1873
- worktree,
1874
- managed_fixed,
1875
- "task-status",
1876
- "REVIEW-RETRY-REPAIR",
1877
- "--json",
1878
- ).stdout
1879
- )["tasks"][0]
1880
- deadline_review = deadline_status["review"]
1881
- deadline_evidence_paths = [
1882
- Path(deadline_review["runtime_retry_audit_path"]),
1883
- Path(deadline_review["runtime_result_path"]),
1884
- Path(deadline_review["runtime_receipt_path"]),
1885
- Path(deadline_review["runtime_event_log_path"]),
1886
- ]
1887
- old_evidence.update({path: path.read_bytes() for path in deadline_evidence_paths})
1888
- final_retry = json.loads(
1889
- self.ap_script(
1890
- worktree,
1891
- managed_final,
1892
- "review-runtime-retry",
1893
- "REVIEW-RETRY-REPAIR",
1894
- "--diff-fingerprint",
1895
- fingerprint,
1896
- "--reason-code",
1897
- "managed-review-artifact-access",
1898
- "--confirm-managed-runtime-retry",
1899
- "--json",
1900
- ).stdout
1901
- )
1902
- self.assertEqual("retry-v4.3.7", final_retry["retry_token"])
1903
- final_audit = json.loads(Path(final_retry["audit_path"]).read_text(encoding="utf-8"))
1904
- self.assertEqual("retry-v4.3.6", final_audit["superseded_retry_token"])
1905
- reviewed = json.loads(
1906
- self.ap_script(
1907
- worktree,
1908
- managed_final,
1909
- "review-run",
1910
- "REVIEW-RETRY-REPAIR",
1911
- "--reviewer",
1912
- "repair-reviewer",
1913
- "--runner-command-json",
1914
- self.artifact_reviewer_runner(
1915
- root,
1916
- "repair retry payload",
1917
- runtime_script=managed_final,
1918
- ),
1919
- "--json",
1920
- ).stdout
1921
- )
1922
- self.assertEqual("approved", reviewed["verdict"])
1923
- for path, original in old_evidence.items():
1924
- self.assertEqual(original, path.read_bytes(), str(path))
1925
-
1926
- def test_managed_retry_rejects_a_substantive_blocked_result(self) -> None:
1927
- root, repo, _ = self.make_repo()
1928
- managed_script = self.managed_runtime(root)
1929
- worktree = self.start_task(repo, "REVIEW-RETRY-FINDING", "shared.txt")
1930
- (worktree / "shared.txt").write_text("substantive retry rejection\n", encoding="utf-8")
1931
- reviewer = root / "substantive-block.py"
1932
- reviewer.write_text(
1933
- "import json\n"
1934
- "print(json.dumps({'verdict': 'blocked', 'summary': 'real correctness defect', "
1935
- "'findings': ['P1: incorrect authorization check'], "
1936
- "'risks': ['Production authorization can be bypassed.']}))\n",
1937
- encoding="utf-8",
1938
- )
1939
- self.ap(
1940
- worktree,
1941
- "review-run",
1942
- "REVIEW-RETRY-FINDING",
1943
- "--reviewer",
1944
- "finding-reviewer",
1945
- "--runner-command-json",
1946
- json.dumps([sys.executable, str(reviewer)]),
1947
- check=False,
1948
- )
1949
- manifest_path = self.registry_manifest_path(repo, "REVIEW-RETRY-FINDING")
1950
- manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
1951
- manifest["skill_version"] = "4.3.2"
1952
- manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
1953
- rejected = self.ap_script(
1954
- worktree,
1955
- managed_script,
1956
- "review-runtime-retry",
1957
- "REVIEW-RETRY-FINDING",
1958
- "--diff-fingerprint",
1959
- manifest["review"]["diff_fingerprint"],
1960
- "--reason-code",
1961
- "managed-review-artifact-access",
1962
- "--confirm-managed-runtime-retry",
1963
- check=False,
1964
- )
1965
- self.assertNotEqual(0, rejected.returncode)
1966
- self.assertIn(
1967
- "not the exact eligible non-substantive",
1968
- rejected.stdout + rejected.stderr,
1969
- )
1970
-
1971
- def test_review_run_retries_runtime_unavailable_and_allows_bound_user_override(self) -> None:
1972
- root, repo, _ = self.make_repo()
1973
- worktree = self.start_task(repo, "REVIEW-TIMEOUT", "shared.txt")
1974
- (worktree / "shared.txt").write_text("review me slowly\n", encoding="utf-8")
1975
- issued = json.loads(
1976
- self.ap(
1977
- worktree,
1978
- "review-assignment",
1979
- "REVIEW-TIMEOUT",
1980
- "--reviewer",
1981
- "reviewer-timeout",
1982
- "--json",
1983
- ).stdout
1984
- )
1985
- self.shorten_review_deadline(repo, "REVIEW-TIMEOUT", issued, seconds=5)
1986
-
1987
- slow_reviewer = root / "slow-reviewer.py"
1988
- slow_reviewer.write_text("import time\ntime.sleep(30)\n", encoding="utf-8")
1989
- started = time.monotonic()
1990
- previous_startup_timeout = os.environ.get("AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS")
1991
- os.environ["AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS"] = "0.1"
1992
- try:
1993
- timed_out = self.ap(
1994
- worktree,
1995
- "review-run",
1996
- "REVIEW-TIMEOUT",
1997
- "--reviewer",
1998
- "reviewer-timeout",
1999
- "--runner-command-json",
2000
- json.dumps([sys.executable, str(slow_reviewer)]),
2001
- check=False,
2002
- )
2003
- finally:
2004
- if previous_startup_timeout is None:
2005
- os.environ.pop("AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS", None)
2006
- else:
2007
- os.environ["AUTOCODING_REVIEW_STARTUP_TIMEOUT_SECONDS"] = previous_startup_timeout
2008
- elapsed = time.monotonic() - started
2009
- self.assertNotEqual(0, timed_out.returncode)
2010
- self.assertLess(elapsed, 6.0)
2011
- self.assertIn("runtime-unavailable", timed_out.stdout + timed_out.stderr)
2012
- status = json.loads(
2013
- self.ap(worktree, "task-status", "REVIEW-TIMEOUT", "--json").stdout
2014
- )["tasks"][0]
2015
- self.assertEqual("blocked", status["review"]["verdict"])
2016
- self.assertEqual("runtime-unavailable", status["review"]["runtime_state"])
2017
- receipt = json.loads(Path(status["review"]["runtime_receipt_path"]).read_text())
2018
- self.assertEqual(2, receipt["schema"])
2019
- self.assertEqual("runtime-unavailable", receipt["status"])
2020
- self.assertEqual(2, len(receipt["attempts"]))
2021
- self.assertRegex(receipt["event_log_sha256"], r"^[0-9a-f]{64}$")
2022
-
2023
- receipt_path = Path(status["review"]["runtime_receipt_path"])
2024
- original_receipt = receipt_path.read_bytes()
2025
- tampered_receipt = json.loads(original_receipt)
2026
- tampered_receipt["failure_kind"] = "tampered-before-override"
2027
- receipt_path.write_text(json.dumps(tampered_receipt) + "\n", encoding="utf-8")
2028
- rejected_receipt = self.ap(
2029
- worktree,
2030
- "review-runtime-override",
2031
- "REVIEW-TIMEOUT",
2032
- "--diff-fingerprint",
2033
- status["current_diff_fingerprint"],
2034
- "--authorized-by",
2035
- "product-owner",
2036
- "--authorization-ref",
2037
- "conversation-pre-tamper",
2038
- "--reason",
2039
- "Tampered pre-override evidence must be rejected.",
2040
- "--evidence",
2041
- "targeted tests passed",
2042
- "--confirm-runtime-bypass",
2043
- check=False,
2044
- )
2045
- self.assertNotEqual(0, rejected_receipt.returncode)
2046
- self.assertIn("changed after failure finalization", rejected_receipt.stdout + rejected_receipt.stderr)
2047
- receipt_path.write_bytes(original_receipt)
2048
-
2049
- event_log_path = Path(status["review"]["runtime_event_log_path"])
2050
- original_event_log = event_log_path.read_bytes()
2051
- event_log_path.write_bytes(original_event_log + b'{"event_type":"tampered"}\n')
2052
- rejected_event = self.ap(
2053
- worktree,
2054
- "review-runtime-override",
2055
- "REVIEW-TIMEOUT",
2056
- "--diff-fingerprint",
2057
- status["current_diff_fingerprint"],
2058
- "--authorized-by",
2059
- "product-owner",
2060
- "--authorization-ref",
2061
- "conversation-event-tamper",
2062
- "--reason",
2063
- "Tampered event evidence must be rejected before override.",
2064
- "--evidence",
2065
- "targeted tests passed",
2066
- "--confirm-runtime-bypass",
2067
- check=False,
2068
- )
2069
- self.assertNotEqual(0, rejected_event.returncode)
2070
- self.assertIn("event log changed", rejected_event.stdout + rejected_event.stderr)
2071
- event_log_path.write_bytes(original_event_log)
2072
-
2073
- override = json.loads(
2074
- self.ap(
2075
- worktree,
2076
- "review-runtime-override",
2077
- "REVIEW-TIMEOUT",
2078
- "--diff-fingerprint",
2079
- status["current_diff_fingerprint"],
2080
- "--authorized-by",
2081
- "product-owner",
2082
- "--authorization-ref",
2083
- "conversation-2026-07-17",
2084
- "--reason",
2085
- "User accepted the exhausted Reviewer runtime failure.",
2086
- "--evidence",
2087
- "targeted tests passed",
2088
- "--confirm-runtime-bypass",
2089
- "--json",
2090
- ).stdout
2091
- )
2092
- self.assertEqual("runtime-bypassed", override["verdict"])
2093
- bypassed_status = json.loads(
2094
- self.ap(worktree, "task-status", "REVIEW-TIMEOUT", "--json").stdout
2095
- )["tasks"][0]
2096
- self.assertEqual("runtime-bypassed", bypassed_status["review"]["verdict"])
2097
- self.assertEqual("runtime-bypassed", bypassed_status["review"]["runtime_state"])
2098
-
2099
- receipt_path = Path(bypassed_status["review"]["runtime_receipt_path"])
2100
- original_receipt = receipt_path.read_bytes()
2101
- tampered_receipt = json.loads(original_receipt)
2102
- tampered_receipt["failure_kind"] = "tampered"
2103
- receipt_path.write_text(json.dumps(tampered_receipt) + "\n", encoding="utf-8")
2104
- rejected_tamper = self.ap(
2105
- worktree,
2106
- "commit-push",
2107
- "REVIEW-TIMEOUT",
2108
- "--msg",
2109
- "test: reject tampered runtime bypass",
2110
- check=False,
2111
- )
2112
- self.assertNotEqual(0, rejected_tamper.returncode)
2113
- self.assertIn("receipt SHA-256", rejected_tamper.stdout + rejected_tamper.stderr)
2114
- receipt_path.write_bytes(original_receipt)
2115
-
2116
- pushed = self.ap(
2117
- worktree,
2118
- "commit-push",
2119
- "REVIEW-TIMEOUT",
2120
- "--msg",
2121
- "test: allow bound runtime bypass",
2122
- )
2123
- self.assertIn("commit-push", pushed.stdout + pushed.stderr)
2124
-
2125
- def test_task_review_requires_assignment_and_exact_head(self) -> None:
2126
- _, repo, _ = self.make_repo()
2127
- worktree = self.start_task(repo, "REVIEW-HEAD", "shared.txt")
2128
- (worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
2129
- status = json.loads(
2130
- self.ap(worktree, "task-status", "REVIEW-HEAD", "--json").stdout
2131
- )["tasks"][0]
2132
- missing = self.ap(
2133
- worktree,
2134
- "task-review",
2135
- "REVIEW-HEAD",
2136
- "--verdict",
2137
- "approved",
2138
- "--diff-fingerprint",
2139
- status["current_diff_fingerprint"],
2140
- "--reviewer",
2141
- "reviewer-1",
2142
- check=False,
2143
- )
2144
- self.assertNotEqual(0, missing.returncode)
2145
- self.assertIn("must use review-assignment", missing.stdout + missing.stderr)
2146
-
2147
- issued = json.loads(
2148
- self.ap(
2149
- worktree,
2150
- "review-assignment",
2151
- "REVIEW-HEAD",
2152
- "--reviewer",
2153
- "reviewer-1",
2154
- "--json",
2155
- ).stdout
2156
- )["assignment"]
2157
- git(worktree, "add", "shared.txt")
2158
- git(worktree, "commit", "-qm", "manual task commit")
2159
- stale = self.ap(
2160
- worktree,
2161
- "task-review",
2162
- "REVIEW-HEAD",
2163
- "--verdict",
2164
- "approved",
2165
- "--diff-fingerprint",
2166
- issued["diff_fingerprint"],
2167
- "--reviewer",
2168
- "reviewer-1",
2169
- check=False,
2170
- )
2171
- self.assertNotEqual(0, stale.returncode)
2172
- self.assertIn("HEAD is stale", stale.stdout + stale.stderr)
2173
-
2174
- def test_expired_review_assignment_cannot_be_renewed_or_approved(self) -> None:
2175
- _, repo, _ = self.make_repo()
2176
- worktree = self.start_task(repo, "REVIEW-EXPIRED", "shared.txt")
2177
- (worktree / "shared.txt").write_text("review me\n", encoding="utf-8")
2178
- issued = json.loads(
2179
- self.ap(
2180
- worktree,
2181
- "review-assignment",
2182
- "REVIEW-EXPIRED",
2183
- "--reviewer",
2184
- "reviewer-1",
2185
- "--json",
2186
- ).stdout
2187
- )
2188
- assignment_path = Path(issued["assignment_path"])
2189
- assignment = issued["assignment"]
2190
- past_deadline = datetime.now(timezone.utc).replace(microsecond=0) - timedelta(seconds=1)
2191
- assignment["deadline_at"] = past_deadline.isoformat()
2192
- assignment["issued_at"] = (past_deadline - timedelta(seconds=150)).isoformat()
2193
- assignment_path.write_text(json.dumps(assignment, indent=2) + "\n", encoding="utf-8")
2194
-
2195
- manifest_path = self.registry_manifest_path(repo, "REVIEW-EXPIRED")
2196
- manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
2197
- manifest["review"]["issued_at"] = assignment["issued_at"]
2198
- manifest["review"]["deadline_at"] = assignment["deadline_at"]
2199
- manifest["review"]["assignment_sha256"] = hashlib.sha256(
2200
- assignment_path.read_bytes()
2201
- ).hexdigest()
2202
- manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
2203
-
2204
- renewed = self.ap(
2205
- worktree,
2206
- "review-assignment",
2207
- "REVIEW-EXPIRED",
2208
- "--reviewer",
2209
- "reviewer-1",
2210
- check=False,
2211
- )
2212
- self.assertNotEqual(0, renewed.returncode)
2213
- self.assertIn("timed out", renewed.stdout + renewed.stderr)
2214
- approved = self.ap(
2215
- worktree,
2216
- "task-review",
2217
- "REVIEW-EXPIRED",
2218
- "--verdict",
2219
- "approved",
2220
- "--diff-fingerprint",
2221
- assignment["diff_fingerprint"],
2222
- "--reviewer",
2223
- "reviewer-1",
2224
- check=False,
2225
- )
2226
- self.assertNotEqual(0, approved.returncode)
2227
- self.assertIn("deadline expired", approved.stdout + approved.stderr)
2228
-
2229
- def test_schema_one_task_status_fails_closed_with_migration_recovery(self) -> None:
2230
- _, repo, _ = self.make_repo()
2231
- self.start_task(repo, "LEGACY-SCHEMA")
2232
- registry = self.registry_manifest_path(repo, "LEGACY-SCHEMA")
2233
- payload = json.loads(registry.read_text(encoding="utf-8"))
2234
- payload["schema"] = 1
2235
- for field in [
2236
- "owned_paths",
2237
- "depends_on",
2238
- "prerequisite_shas",
2239
- "writer_lease",
2240
- "review",
2241
- ]:
2242
- payload.pop(field, None)
2243
- registry.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
2244
-
2245
- result = self.ap(repo, "task-status", "LEGACY-SCHEMA", check=False)
2246
- rendered = result.stdout + result.stderr
2247
- self.assertNotEqual(0, result.returncode)
2248
- self.assertIn("legacy schema-1 task", rendered)
2249
- self.assertIn("cannot safely infer or claim owned_paths", rendered)
2250
- self.assertIn("previously installed runtime", rendered)
2251
- self.assertIn("restore the 3.0.0 runtime", rendered)
2252
-
2253
- def test_owned_paths_are_required_and_unowned_changes_are_rejected(self) -> None:
2254
- _, repo, remote = self.make_repo()
2255
- missing = self.ap(
2256
- repo,
2257
- "task-start",
2258
- "NO-OWNED",
2259
- "--base",
2260
- "origin/dev",
2261
- check=False,
2262
- )
2263
- self.assertNotEqual(0, missing.returncode)
2264
- self.assertIn("owned-path", (missing.stdout + missing.stderr).lower())
2265
- self.assert_remote_branch(remote, "codex/NO-OWNED", False)
2266
-
2267
- self.ap(
2268
- repo,
2269
- "task-start",
2270
- "OWNED-ONLY",
2271
- "--base",
2272
- "origin/dev",
2273
- "--owned-path",
2274
- "src/owned",
2275
- )
2276
- worktree = self.task_worktree(repo, "OWNED-ONLY")
2277
- outside = worktree / "src" / "outside.txt"
2278
- outside.parent.mkdir(parents=True)
2279
- outside.write_text("outside\n", encoding="utf-8")
2280
- status = self.ap(worktree, "task-status", "OWNED-ONLY", "--json")
2281
- fingerprint = json.loads(status.stdout)["tasks"][0]["current_diff_fingerprint"]
2282
- review = self.ap(
2283
- worktree,
2284
- "task-review",
2285
- "OWNED-ONLY",
2286
- "--verdict",
2287
- "approved",
2288
- "--diff-fingerprint",
2289
- fingerprint,
2290
- check=False,
2291
- )
2292
- self.assertNotEqual(0, review.returncode)
2293
- self.assertIn("outside task owned_paths", review.stdout + review.stderr)
2294
-
2295
- def test_approved_fingerprint_expires_when_owned_diff_changes(self) -> None:
2296
- _, repo, remote = self.make_repo()
2297
- worktree = self.start_task(repo, "STALE-REVIEW")
2298
- payload = worktree / "payload.txt"
2299
- payload.write_text("reviewed\n", encoding="utf-8")
2300
- registry = self.registry_manifest_path(repo, "STALE-REVIEW")
2301
- manifest = json.loads(registry.read_text(encoding="utf-8"))
2302
- owner = manifest["owner"]
2303
- manifest["owner"] = "another-lifecycle-owner"
2304
- registry.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
2305
- status = self.ap(worktree, "task-status", "STALE-REVIEW", "--json")
2306
- fingerprint = json.loads(status.stdout)["tasks"][0]["current_diff_fingerprint"]
2307
- non_owner_review = self.ap(
2308
- worktree,
2309
- "task-review",
2310
- "STALE-REVIEW",
2311
- "--verdict",
2312
- "approved",
2313
- "--diff-fingerprint",
2314
- fingerprint,
2315
- check=False,
2316
- )
2317
- self.assertNotEqual(0, non_owner_review.returncode)
2318
- self.assertIn("lifecycle owner", non_owner_review.stdout + non_owner_review.stderr)
2319
- manifest["owner"] = owner
2320
- registry.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
2321
- self.approve_task(worktree, "STALE-REVIEW")
2322
- payload.write_text("changed after review\n", encoding="utf-8")
2323
-
2324
- result = self.ap(
2325
- worktree,
2326
- "commit-push",
2327
- "STALE-REVIEW",
2328
- "--msg",
2329
- "STALE-REVIEW: must fail",
2330
- check=False,
2331
- )
2332
- self.assertNotEqual(0, result.returncode)
2333
- self.assertIn("fingerprint is stale", result.stdout + result.stderr)
2334
- self.assert_remote_branch(remote, "codex/STALE-REVIEW", False)
2335
-
2336
- def test_writer_lease_requires_match_and_owner_handoff_uses_generation_cas(self) -> None:
2337
- _, repo, _ = self.make_repo()
2338
- owner = _TEST_OWNER
2339
- self.ap(
2340
- repo,
2341
- "task-start",
2342
- "LEASE-1",
2343
- "--base",
2344
- "origin/dev",
2345
- "--owned-path",
2346
- ".",
2347
- )
2348
- worktree = self.task_worktree(repo, "LEASE-1")
2349
- (worktree / "lease.txt").write_text("ready\n", encoding="utf-8")
2350
- self.approve_task(worktree, "LEASE-1")
2351
-
2352
- self.ap(
2353
- repo,
2354
- "task-handoff",
2355
- "LEASE-1",
2356
- "--from",
2357
- owner,
2358
- "--to",
2359
- "fixer-label",
2360
- "--generation",
2361
- "1",
2362
- )
2363
-
2364
- mismatch = self.ap(
2365
- worktree,
2366
- "commit-push",
2367
- "LEASE-1",
2368
- "--msg",
2369
- "LEASE-1: wrong writer",
2370
- check=False,
2371
- )
2372
- self.assertNotEqual(0, mismatch.returncode)
2373
- self.assertIn("writer lease mismatch", (mismatch.stdout + mismatch.stderr).lower())
2374
-
2375
- spoofed = self.ap(
2376
- worktree,
2377
- "commit-push",
2378
- "LEASE-1",
2379
- "--msg",
2380
- "LEASE-1: spoofed writer",
2381
- "--writer",
2382
- "fixer-label",
2383
- check=False,
2384
- )
2385
- self.assertNotEqual(0, spoofed.returncode)
2386
- self.assertIn("actor identity cannot be overridden", spoofed.stdout + spoofed.stderr)
2387
-
2388
- self.ap(
2389
- repo,
2390
- "task-handoff",
2391
- "LEASE-1",
2392
- "--from",
2393
- "fixer-label",
2394
- "--to",
2395
- owner,
2396
- "--generation",
2397
- "2",
2398
- )
2399
- stale = self.ap(
2400
- repo,
2401
- "task-handoff",
2402
- "LEASE-1",
2403
- "--from",
2404
- owner,
2405
- "--to",
2406
- "next-writer",
2407
- "--generation",
2408
- "2",
2409
- check=False,
2410
- )
2411
- self.assertNotEqual(0, stale.returncode)
2412
- self.assertIn("generation changed", stale.stdout + stale.stderr)
2413
- manifest = json.loads(self.registry_manifest_path(repo, "LEASE-1").read_text(encoding="utf-8"))
2414
- self.assertEqual(owner, manifest["writer_lease"]["holder"])
2415
- self.assertEqual(3, manifest["writer_lease"]["generation"])
2416
-
2417
- def test_dependency_sha_must_already_be_in_task_base(self) -> None:
2418
- _, repo, _ = self.make_repo()
2419
- tree = git_output(repo, "rev-parse", "HEAD^{tree}")
2420
- orphan = git_output(repo, "commit-tree", tree, "-m", "unintegrated prerequisite")
2421
- result = self.ap(
2422
- repo,
2423
- "task-start",
2424
- "DEPENDENT-1",
2425
- "--base",
2426
- "origin/dev",
2427
- "--owned-path",
2428
- ".",
2429
- "--depends-on",
2430
- f"UPSTREAM-1={orphan}",
2431
- check=False,
2432
- )
2433
- self.assertNotEqual(0, result.returncode)
2434
- self.assertIn("not integrated", result.stdout + result.stderr)
2435
-
2436
- def test_target_advance_rebases_then_requires_review_before_integration(self) -> None:
2437
- _, repo, remote = self.make_repo()
2438
- worktree = self.start_task(repo, "REBASE-REVIEW")
2439
- (worktree / "task.txt").write_text("task\n", encoding="utf-8")
2440
- self.commit_push(worktree, "REBASE-REVIEW", "REBASE-REVIEW: ready")
2441
-
2442
- (repo / "upstream.txt").write_text("upstream\n", encoding="utf-8")
2443
- git(repo, "add", "upstream.txt")
2444
- git(repo, "commit", "-qm", "advance target")
2445
- git(repo, "push", "-q", "origin", "dev")
2446
-
2447
- rebased = self.ap(repo, "task-integrate", "REBASE-REVIEW", check=False)
2448
- self.assertNotEqual(0, rebased.returncode)
2449
- self.assertIn("review again", rebased.stdout + rebased.stderr)
2450
- manifest = json.loads(self.registry_manifest_path(repo, "REBASE-REVIEW").read_text(encoding="utf-8"))
2451
- self.assertEqual("pushed", manifest["state"])
2452
- self.assertEqual("pending", manifest["review"]["verdict"])
2453
- self.assertNotEqual(
2454
- 0,
2455
- git(remote, "cat-file", "-e", "refs/heads/dev:task.txt", check=False).returncode,
2456
- )
2457
-
2458
- self.approve_task(worktree, "REBASE-REVIEW")
2459
- self.ap(repo, "task-integrate", "REBASE-REVIEW")
2460
- self.assertEqual("task", git_output(remote, "show", "refs/heads/dev:task.txt"))
2461
-
2462
- def test_rebase_conflict_can_resume_only_then_requires_fresh_review(self) -> None:
2463
- _, repo, remote = self.make_repo()
2464
- worktree = self.start_task(repo, "RESUME-1")
2465
- (worktree / "shared.txt").write_text("task side\n", encoding="utf-8")
2466
- self.commit_push(worktree, "RESUME-1", "RESUME-1: ready")
2467
-
2468
- (repo / "shared.txt").write_text("target side\n", encoding="utf-8")
2469
- git(repo, "add", "shared.txt")
2470
- git(repo, "commit", "-qm", "conflicting target change")
2471
- git(repo, "push", "-q", "origin", "dev")
2472
-
2473
- conflict = self.ap(repo, "task-integrate", "RESUME-1", check=False)
2474
- self.assertNotEqual(0, conflict.returncode)
2475
- self.assertIn("rebase conflicted", conflict.stdout + conflict.stderr)
2476
- manifest = json.loads(self.registry_manifest_path(repo, "RESUME-1").read_text(encoding="utf-8"))
2477
- self.assertEqual("conflicted", manifest["state"])
2478
- self.assertEqual("pending", manifest["review"]["verdict"])
2479
-
2480
- (worktree / "shared.txt").write_text("resolved\n", encoding="utf-8")
2481
- git(worktree, "add", "shared.txt")
2482
- git(worktree, "-c", "core.editor=true", "rebase", "--continue")
2483
- self.ap(repo, "task-resume", "RESUME-1")
2484
- manifest = json.loads(self.registry_manifest_path(repo, "RESUME-1").read_text(encoding="utf-8"))
2485
- self.assertEqual("pushed", manifest["state"])
2486
- self.assertEqual("pending", manifest["review"]["verdict"])
2487
-
2488
- self.approve_task(worktree, "RESUME-1")
2489
- self.ap(repo, "task-integrate", "RESUME-1")
2490
- self.assertEqual("resolved", git_output(remote, "show", "refs/heads/dev:shared.txt"))
2491
-
2492
- def test_task_start_rolls_back_checkout_hook_side_effects(self) -> None:
2493
- hook_bodies = {
2494
- "untracked": (
2495
- 'root="$(git rev-parse --show-toplevel)"\n'
2496
- 'printf "hook data\\n" > "$root/hook-created.txt"\n'
2497
- ),
2498
- "clean-commit": (
2499
- 'root="$(git rev-parse --show-toplevel)"\n'
2500
- 'printf "hook commit\\n" > "$root/hook-created.txt"\n'
2501
- 'git -C "$root" add hook-created.txt\n'
2502
- 'git -C "$root" commit --no-verify -qm "checkout hook commit"\n'
2503
- ),
2504
- }
2505
- for label, body in hook_bodies.items():
2506
- with self.subTest(label=label):
2507
- root, repo, _ = self.make_repo()
2508
- self.install_hook(repo, "post-checkout", body)
2509
- task_id = f"HOOK-{label.upper()}"
2510
-
2511
- result = self.ap(
2512
- repo,
2513
- "task-start",
2514
- task_id,
2515
- "--base",
2516
- "origin/dev",
2517
- "--owned-path",
2518
- ".",
2519
- check=False,
2520
- )
2521
-
2522
- self.assertNotEqual(0, result.returncode)
2523
- self.assertIn("hook", (result.stdout + result.stderr).lower())
2524
- self.assert_local_branch(repo, f"codex/{task_id}", False)
2525
- self.assertFalse(self.registry_manifest_path(repo, task_id).exists())
2526
- self.assertNotIn(
2527
- f"refs/heads/codex/{task_id}",
2528
- git_output(repo, "worktree", "list", "--porcelain"),
2529
- )
2530
- self.assertFalse((root / "worktrees" / repo.name / task_id).exists())
2531
-
2532
- def test_control_commands_are_rejected_from_another_task_worktree(self) -> None:
2533
- _, repo, _ = self.make_repo()
2534
- first = self.start_task(repo, "CROSS-1", "cross/one")
2535
- second = self.start_task(repo, "CROSS-2", "cross/two")
2536
-
2537
- commands = [
2538
- ("task-integrate", "CROSS-1"),
2539
- ("task-finish", "CROSS-1"),
2540
- ("task-prune",),
2541
- ("task-start", "CROSS-3"),
2542
- ]
2543
- for args in commands:
2544
- with self.subTest(command=args[0]):
2545
- before = {
2546
- "control_head": git_output(repo, "rev-parse", "HEAD"),
2547
- "control_status": git_output(repo, "status", "--porcelain=v1"),
2548
- "first_head": git_output(first, "rev-parse", "HEAD"),
2549
- "first_status": git_output(first, "status", "--porcelain=v1"),
2550
- "second_head": git_output(second, "rev-parse", "HEAD"),
2551
- "second_status": git_output(second, "status", "--porcelain=v1"),
2552
- "worktrees": git_output(repo, "worktree", "list", "--porcelain"),
2553
- }
2554
- result = self.ap(second, *args, check=False)
2555
- self.assertNotEqual(0, result.returncode)
2556
- self.assertIn("control", (result.stdout + result.stderr).lower())
2557
- after = {
2558
- "control_head": git_output(repo, "rev-parse", "HEAD"),
2559
- "control_status": git_output(repo, "status", "--porcelain=v1"),
2560
- "first_head": git_output(first, "rev-parse", "HEAD"),
2561
- "first_status": git_output(first, "status", "--porcelain=v1"),
2562
- "second_head": git_output(second, "rev-parse", "HEAD"),
2563
- "second_status": git_output(second, "status", "--porcelain=v1"),
2564
- "worktrees": git_output(repo, "worktree", "list", "--porcelain"),
2565
- }
2566
- self.assertEqual(before, after)
2567
-
2568
- def test_task_start_rejects_overlapping_active_owned_paths(self) -> None:
2569
- _, repo, _ = self.make_repo()
2570
- first = self.start_task(repo, "OWNER-1", "backend")
2571
- result = self.ap(
2572
- repo,
2573
- "task-start",
2574
- "OWNER-2",
2575
- "--base",
2576
- "origin/dev",
2577
- "--owned-path",
2578
- "backend/api",
2579
- "--isolated",
2580
- check=False,
2581
- )
2582
- self.assertNotEqual(0, result.returncode)
2583
- self.assertIn("overlap active task OWNER-1", result.stdout + result.stderr)
2584
- self.assertTrue(first.exists())
2585
- self.assertFalse(self.registry_manifest_path(repo, "OWNER-2").exists())
2586
- self.assert_local_branch(repo, "codex/OWNER-2", False)
2587
-
2588
- def test_task_start_rejects_terminal_ledger_lifecycle_and_multi_writer(self) -> None:
2589
- _, repo, _ = self.make_repo()
2590
- terminal = self.ap(
2591
- repo,
2592
- "task-start",
2593
- "LEDGER-END",
2594
- "--base",
2595
- "origin/dev",
2596
- "--owned-path",
2597
- "docs/tasks/closure-log.md",
2598
- check=False,
2599
- )
2600
- self.assertNotEqual(0, terminal.returncode)
2601
- self.assertIn("terminal maintenance", terminal.stdout + terminal.stderr)
2602
- self.assertFalse(self.registry_manifest_path(repo, "LEDGER-END").exists())
2603
-
2604
- multi = self.ap(
2605
- repo,
2606
- "task-start",
2607
- "MULTI-1",
2608
- "--base",
2609
- "origin/dev",
2610
- "--owned-path",
2611
- "frontend",
2612
- "--writers",
2613
- "2",
2614
- check=False,
2615
- )
2616
- self.assertNotEqual(0, multi.returncode)
2617
- self.assertIn("exactly one writer lease", multi.stdout + multi.stderr)
2618
- self.assertFalse(self.registry_manifest_path(repo, "MULTI-1").exists())
2619
-
2620
- def test_missing_task_manifest_is_rejected_in_linked_worktree(self) -> None:
2621
- _, repo, remote = self.make_repo("worktree")
2622
- worktree = self.start_task(repo, "NO-MANIFEST")
2623
- git_dir = Path(git_output(worktree, "rev-parse", "--git-dir"))
2624
- if not git_dir.is_absolute():
2625
- git_dir = (worktree / git_dir).resolve()
2626
- (git_dir / "auto-coding-skill-task.json").unlink()
2627
- before = git_output(worktree, "rev-parse", "HEAD")
2628
- (worktree / "payload.txt").write_text("must not publish\n", encoding="utf-8")
2629
-
2630
- result = self.ap(
2631
- worktree,
2632
- "commit-push",
2633
- "NO-MANIFEST",
2634
- "--msg",
2635
- "NO-MANIFEST: must fail",
2636
- check=False,
2637
- )
2638
-
2639
- self.assertNotEqual(0, result.returncode)
2640
- self.assertIn("manifest", (result.stdout + result.stderr).lower())
2641
- self.assertEqual(before, git_output(worktree, "rev-parse", "HEAD"))
2642
- self.assert_remote_branch(remote, "codex/NO-MANIFEST", False)
2643
-
2644
- def test_corrupt_manifest_cannot_redirect_cleanup_to_control_branch(self) -> None:
2645
- _, repo, remote = self.make_repo()
2646
- worktree = self.start_task(repo, "CORRUPT-1")
2647
- registry = self.registry_manifest_path(repo, "CORRUPT-1")
2648
- worktree_git_dir = Path(git_output(worktree, "rev-parse", "--git-dir"))
2649
- if not worktree_git_dir.is_absolute():
2650
- worktree_git_dir = (worktree / worktree_git_dir).resolve()
2651
- worktree_manifest = worktree_git_dir / "auto-coding-skill-task.json"
2652
- payload = json.loads(registry.read_text(encoding="utf-8"))
2653
- payload["task_branch"] = "dev"
2654
- rendered = json.dumps(payload, indent=2, sort_keys=True) + "\n"
2655
- registry.write_text(rendered, encoding="utf-8")
2656
- worktree_manifest.write_text(rendered, encoding="utf-8")
2657
- local_dev = git_output(repo, "rev-parse", "refs/heads/dev")
2658
- remote_dev = git_output(remote, "rev-parse", "refs/heads/dev")
2659
-
2660
- result = self.ap(repo, "task-finish", "CORRUPT-1", check=False)
2661
-
2662
- self.assertNotEqual(0, result.returncode)
2663
- self.assertIn("invalid task branch", (result.stdout + result.stderr).lower())
2664
- self.assertEqual(local_dev, git_output(repo, "rev-parse", "refs/heads/dev"))
2665
- self.assertEqual(remote_dev, git_output(remote, "rev-parse", "refs/heads/dev"))
2666
- self.assertTrue(worktree.exists())
2667
- self.assert_local_branch(repo, "codex/CORRUPT-1", True)
2668
-
2669
- def test_commit_push_requires_matching_manifest_and_isolated_worktree(self) -> None:
2670
- _, repo, remote = self.make_repo()
2671
- worktree = self.start_task(repo, "ISOLATED-1", "task-only.txt")
2672
- second_worktree = self.start_task(repo, "ISOLATED-2", "second-task-only.txt")
2673
- (worktree / "task-only.txt").write_text("task change\n", encoding="utf-8")
2674
- (second_worktree / "second-task-only.txt").write_text(
2675
- "second task change\n",
2676
- encoding="utf-8",
2677
- )
2678
- (repo / "shared.txt").write_text("primary checkout change\n", encoding="utf-8")
2679
-
2680
- mismatch = self.assert_rejected_without_mutation(
2681
- worktree,
2682
- "commit-push",
2683
- "ANOTHER-TASK",
2684
- "--msg",
2685
- "ANOTHER-TASK: must fail",
2686
- )
2687
- self.assertIn("task", (mismatch.stdout + mismatch.stderr).lower())
2688
-
2689
- primary = self.assert_rejected_without_mutation(
2690
- repo,
2691
- "commit-push",
2692
- "ISOLATED-1",
2693
- "--msg",
2694
- "ISOLATED-1: must fail from primary checkout",
2695
- )
2696
- self.assertIn("worktree", (primary.stdout + primary.stderr).lower())
2697
-
2698
- second_status = git(second_worktree, "status", "--short").stdout
2699
- self.assertIn("?? second-task-only.txt", second_status)
2700
- self.approve_task(worktree, "ISOLATED-1")
2701
- self.approve_task(second_worktree, "ISOLATED-2")
2702
- with ThreadPoolExecutor(max_workers=2) as pool:
2703
- first_commit = pool.submit(
2704
- self.ap,
2705
- worktree,
2706
- "commit-push",
2707
- "ISOLATED-1",
2708
- "--msg",
2709
- "ISOLATED-1: isolated change",
2710
- )
2711
- second_commit = pool.submit(
2712
- self.ap,
2713
- second_worktree,
2714
- "commit-push",
2715
- "ISOLATED-2",
2716
- "--msg",
2717
- "ISOLATED-2: independent change",
2718
- )
2719
- first_commit.result()
2720
- second_commit.result()
2721
-
2722
- self.assert_remote_branch(remote, "codex/ISOLATED-1", True)
2723
- task_ref = "refs/heads/codex/ISOLATED-1"
2724
- self.assertEqual(
2725
- "task change",
2726
- git_output(remote, "show", f"{task_ref}:task-only.txt"),
2727
- )
2728
- self.assertEqual("baseline", git_output(remote, "show", f"{task_ref}:shared.txt"))
2729
- self.assertNotEqual(
2730
- 0,
2731
- git(
2732
- remote,
2733
- "cat-file",
2734
- "-e",
2735
- f"{task_ref}:second-task-only.txt",
2736
- check=False,
2737
- ).returncode,
2738
- )
2739
- self.assertEqual("primary checkout change\n", (repo / "shared.txt").read_text(encoding="utf-8"))
2740
- self.assertEqual(" M shared.txt\n", git(repo, "status", "--short").stdout)
2741
- second_ref = "refs/heads/codex/ISOLATED-2"
2742
- self.assertEqual(
2743
- "second task change",
2744
- git_output(remote, "show", f"{second_ref}:second-task-only.txt"),
2745
- )
2746
- self.assertNotEqual(
2747
- 0,
2748
- git(remote, "cat-file", "-e", f"{second_ref}:task-only.txt", check=False).returncode,
2749
- )
2750
-
2751
- def test_task_integrate_from_primary_pushes_target_and_cleans_task_refs(self) -> None:
2752
- root, repo, remote = self.make_repo()
2753
- gate_marker = root / "gate-invocations"
2754
- commit_hook_marker = root / "commit-hook-invocations"
2755
- push_hook_marker = root / "push-hook-invocations"
2756
- engineering = repo / "docs" / "ENGINEERING.md"
2757
- original = engineering.read_text(encoding="utf-8")
2758
- configured = original.replace(
2759
- "gate_changed: 'true'",
2760
- f"gate_changed: 'printf x >> {gate_marker}'",
2761
- )
2762
- self.assertNotEqual(original, configured)
2763
- engineering.write_text(configured, encoding="utf-8")
2764
- git(repo, "add", "docs/ENGINEERING.md")
2765
- git(repo, "commit", "-qm", "configure observable fast gate")
2766
- git(repo, "push", "-q", "origin", "dev")
2767
- self.install_hook(repo, "pre-commit", f"printf c >> '{commit_hook_marker}'\n")
2768
- self.install_hook(repo, "pre-push", f"printf p >> '{push_hook_marker}'\n")
2769
-
2770
- worktree = self.start_task(repo, "INTEGRATE-1")
2771
- (worktree / "integrated.txt").write_text("integrated\n", encoding="utf-8")
2772
- self.commit_push(worktree, "INTEGRATE-1", "INTEGRATE-1: ready")
2773
- review_dir = Path(
2774
- json.loads(
2775
- self.registry_manifest_path(repo, "INTEGRATE-1").read_text(encoding="utf-8")
2776
- )["review"]["assignment_path"]
2777
- ).parent
2778
- self.assertTrue(review_dir.is_dir())
2779
- task_commit = git_output(worktree, "rev-parse", "HEAD")
2780
- self.assertEqual("c", commit_hook_marker.read_text(encoding="utf-8"))
2781
- self.assertFalse(
2782
- push_hook_marker.exists(),
2783
- "the internal backup push must not duplicate the final pre-push hook",
2784
- )
2785
-
2786
- rejected = self.ap(worktree, "task-integrate", "INTEGRATE-1", check=False)
2787
- self.assertNotEqual(0, rejected.returncode)
2788
- self.assertTrue(worktree.exists())
2789
- self.assert_remote_branch(remote, "codex/INTEGRATE-1", True)
2790
-
2791
- (repo / "shared.txt").write_text("primary work stays untouched\n", encoding="utf-8")
2792
- self.ap(repo, "task-integrate", "INTEGRATE-1")
2793
-
2794
- self.assertEqual("integrated", git_output(remote, "show", "refs/heads/dev:integrated.txt"))
2795
- self.assertEqual(
2796
- "primary work stays untouched\n",
2797
- (repo / "shared.txt").read_text(encoding="utf-8"),
2798
- )
2799
- self.assertFalse(worktree.exists())
2800
- self.assert_local_branch(repo, "codex/INTEGRATE-1", False)
2801
- self.assert_remote_branch(remote, "codex/INTEGRATE-1", False)
2802
- self.assertFalse(review_dir.exists())
2803
- self.assertEqual("x", gate_marker.read_text(encoding="utf-8"), "push flow must run the fast gate exactly once")
2804
- self.assertEqual("c", commit_hook_marker.read_text(encoding="utf-8"), "push flow must create exactly one hook-visible commit")
2805
- self.assertEqual("p", push_hook_marker.read_text(encoding="utf-8"), "the final target push hook must run exactly once")
2806
- self.assertEqual(task_commit, git_output(remote, "rev-parse", "refs/heads/dev"), "integration must not create a second evidence commit")
2807
-
2808
- def test_task_integrate_rejects_legacy_gate_failed_state(self) -> None:
2809
- _, repo, remote = self.make_repo()
2810
- worktree = self.start_task(repo, "FAILED-GATE")
2811
- (worktree / "must-not-integrate.txt").write_text("blocked\n", encoding="utf-8")
2812
- self.commit_push(worktree, "FAILED-GATE", "FAILED-GATE: staged task")
2813
- registry = self.registry_manifest_path(repo, "FAILED-GATE")
2814
- payload = json.loads(registry.read_text(encoding="utf-8"))
2815
- payload["state"] = "gate-failed"
2816
- registry.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
2817
-
2818
- result = self.ap(repo, "task-integrate", "FAILED-GATE", check=False)
2819
-
2820
- self.assertNotEqual(0, result.returncode)
2821
- self.assertIn("committed and pushed", (result.stdout + result.stderr).lower())
2822
- self.assertTrue(worktree.exists())
2823
- self.assertNotEqual(
2824
- 0,
2825
- git(remote, "cat-file", "-e", "refs/heads/dev:must-not-integrate.txt", check=False).returncode,
2826
- )
2827
-
2828
- def test_task_finish_keep_remote_reports_retained_branch(self) -> None:
2829
- _, repo, remote = self.make_repo()
2830
- worktree = self.start_task(repo, "KEEP-REMOTE")
2831
- (worktree / "kept.txt").write_text("kept remotely\n", encoding="utf-8")
2832
- self.commit_push(worktree, "KEEP-REMOTE", "KEEP-REMOTE: ready")
2833
- self.ap(repo, "task-integrate", "KEEP-REMOTE", "--keep-worktree")
2834
-
2835
- finish = self.ap(repo, "task-finish", "KEEP-REMOTE", "--keep-remote")
2836
-
2837
- self.assertIn("remote_branch_deleted=false", finish.stdout + finish.stderr)
2838
- self.assertFalse(worktree.exists())
2839
- self.assert_local_branch(repo, "codex/KEEP-REMOTE", False)
2840
- self.assert_remote_branch(remote, "codex/KEEP-REMOTE", True)
2841
- self.assertFalse(self.registry_manifest_path(repo, "KEEP-REMOTE").exists())
2842
-
2843
- def test_task_deletion_is_isolated_and_committed_only_on_its_task_branch(self) -> None:
2844
- _, repo, remote = self.make_repo()
2845
- deleting = self.start_task(repo, "DELETE-1", "shared.txt")
2846
- observer = self.start_task(repo, "DELETE-2", "observer.txt")
2847
- (deleting / "shared.txt").unlink()
2848
- (observer / "observer.txt").write_text("observer\n", encoding="utf-8")
2849
-
2850
- self.commit_push(deleting, "DELETE-1", "DELETE-1: delete shared file")
2851
-
2852
- deleted_ref = "refs/heads/codex/DELETE-1"
2853
- self.assertNotEqual(
2854
- 0,
2855
- git(remote, "cat-file", "-e", f"{deleted_ref}:shared.txt", check=False).returncode,
2856
- )
2857
- self.assertEqual("baseline\n", (repo / "shared.txt").read_text(encoding="utf-8"))
2858
- self.assertEqual("baseline\n", (observer / "shared.txt").read_text(encoding="utf-8"))
2859
- self.assertTrue((observer / "observer.txt").exists())
2860
-
2861
- def test_task_finish_refuses_dirty_or_unmerged_tasks(self) -> None:
2862
- _, repo, _ = self.make_repo()
2863
-
2864
- dirty_worktree = self.start_task(repo, "DIRTY-1", "dirty.txt")
2865
- (dirty_worktree / "dirty.txt").write_text("not committed\n", encoding="utf-8")
2866
- dirty = self.ap(repo, "task-finish", "DIRTY-1", check=False)
2867
- self.assertNotEqual(0, dirty.returncode)
2868
- self.assertTrue(dirty_worktree.exists())
2869
- self.assert_local_branch(repo, "codex/DIRTY-1", True)
2870
- self.assertTrue((dirty_worktree / "dirty.txt").exists())
2871
-
2872
- unmerged_worktree = self.start_task(repo, "UNMERGED-1", "unmerged.txt")
2873
- (unmerged_worktree / "unmerged.txt").write_text("committed only on task\n", encoding="utf-8")
2874
- git(unmerged_worktree, "add", "unmerged.txt")
2875
- git(unmerged_worktree, "commit", "-qm", "unmerged task commit")
2876
- unmerged = self.ap(repo, "task-finish", "UNMERGED-1", check=False)
2877
- self.assertNotEqual(0, unmerged.returncode)
2878
- self.assertTrue(unmerged_worktree.exists())
2879
- self.assert_local_branch(repo, "codex/UNMERGED-1", True)
2880
- self.assertEqual("unmerged task commit", git_output(unmerged_worktree, "log", "-1", "--format=%s"))
2881
-
2882
- def test_task_prune_only_removes_merged_unoccupied_codex_branches(self) -> None:
2883
- root, repo, _ = self.make_repo()
2884
- git(repo, "branch", "codex/merged-free", "dev")
2885
- git(repo, "branch", "feature/merged-free", "dev")
2886
-
2887
- git(repo, "branch", "codex/unmerged-free", "dev")
2888
- unmerged_path = root / "unmerged-worktree"
2889
- git(repo, "worktree", "add", "-q", str(unmerged_path), "codex/unmerged-free")
2890
- (unmerged_path / "unique.txt").write_text("unique\n", encoding="utf-8")
2891
- git(unmerged_path, "add", "unique.txt")
2892
- git(unmerged_path, "commit", "-qm", "unique unmerged commit")
2893
- git(repo, "worktree", "remove", str(unmerged_path))
2894
-
2895
- git(repo, "branch", "codex/merged-occupied", "dev")
2896
- occupied_path = root / "occupied-worktree"
2897
- git(repo, "worktree", "add", "-q", str(occupied_path), "codex/merged-occupied")
2898
-
2899
- self.ap(repo, "task-prune")
2900
-
2901
- self.assert_local_branch(repo, "codex/merged-free", False)
2902
- self.assert_local_branch(repo, "codex/unmerged-free", True)
2903
- self.assert_local_branch(repo, "codex/merged-occupied", True)
2904
- self.assert_local_branch(repo, "feature/merged-free", True)
2905
- self.assertTrue(occupied_path.exists())
2906
-
2907
- def test_task_prune_finishes_registered_integrated_worktree(self) -> None:
2908
- _, repo, remote = self.make_repo()
2909
- worktree = self.start_task(repo, "PRUNE-REGISTERED")
2910
- (worktree / "registered.txt").write_text("registered\n", encoding="utf-8")
2911
- self.commit_push(worktree, "PRUNE-REGISTERED", "PRUNE-REGISTERED: ready")
2912
- self.ap(
2913
- repo,
2914
- "task-integrate",
2915
- "PRUNE-REGISTERED",
2916
- "--keep-worktree",
2917
- )
2918
- self.assertTrue(worktree.exists())
2919
- self.assert_local_branch(repo, "codex/PRUNE-REGISTERED", True)
2920
-
2921
- self.ap(repo, "task-prune")
2922
-
2923
- self.assertFalse(worktree.exists())
2924
- self.assert_local_branch(repo, "codex/PRUNE-REGISTERED", False)
2925
- self.assert_remote_branch(remote, "codex/PRUNE-REGISTERED", False)
2926
-
2927
- def test_task_prune_removes_orphan_git_local_review_artifacts(self) -> None:
2928
- _, repo, _ = self.make_repo()
2929
- worktree = self.start_task(repo, "PRUNE-REVIEW-ORPHAN", "shared.txt")
2930
- (worktree / "shared.txt").write_text("orphan review\n", encoding="utf-8")
2931
- issued = json.loads(
2932
- self.ap(
2933
- worktree,
2934
- "review-assignment",
2935
- "PRUNE-REVIEW-ORPHAN",
2936
- "--reviewer",
2937
- "reviewer-orphan",
2938
- "--json",
2939
- ).stdout
2940
- )
2941
- review_dir = Path(issued["assignment_path"]).parent
2942
- self.assertTrue(review_dir.is_dir())
2943
- git(repo, "worktree", "unlock", str(worktree))
2944
- git(repo, "worktree", "remove", "--force", str(worktree))
2945
- self.registry_manifest_path(repo, "PRUNE-REVIEW-ORPHAN").unlink()
2946
-
2947
- self.ap(repo, "task-prune")
2948
-
2949
- self.assertFalse(review_dir.exists())
2950
- self.assert_local_branch(repo, "codex/PRUNE-REVIEW-ORPHAN", False)
2951
-
2952
- def test_cleanup_blocks_unknown_ignored_data_but_allows_runtime_evidence(self) -> None:
2953
- _, repo, remote = self.make_repo()
2954
- (repo / ".gitignore").write_text(".env\n.local/\n", encoding="utf-8")
2955
- git(repo, "add", ".gitignore")
2956
- git(repo, "commit", "-qm", "ignore local runtime files")
2957
- git(repo, "push", "-q", "origin", "dev")
2958
-
2959
- worktree = self.start_task(repo, "IGNORED-1")
2960
- (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
2961
- self.commit_push(worktree, "IGNORED-1", "IGNORED-1: ready")
2962
- self.ap(repo, "task-integrate", "IGNORED-1", "--keep-worktree")
2963
-
2964
- (worktree / ".env").write_text("must survive\n", encoding="utf-8")
2965
- blocked = self.ap(repo, "task-finish", "IGNORED-1", check=False)
2966
- self.assertNotEqual(0, blocked.returncode)
2967
- self.assertIn(".env", blocked.stdout + blocked.stderr)
2968
- self.assertTrue(worktree.exists())
2969
- self.assertEqual("must survive\n", (worktree / ".env").read_text(encoding="utf-8"))
2970
-
2971
- (worktree / ".env").unlink()
2972
- runtime_evidence = worktree / ".local" / "auto-coding-skill" / "gate.jsonl"
2973
- runtime_evidence.parent.mkdir(parents=True, exist_ok=True)
2974
- runtime_evidence.write_text("runtime evidence\n", encoding="utf-8")
2975
- self.ap(repo, "task-finish", "IGNORED-1")
2976
-
2977
- self.assertFalse(worktree.exists())
2978
- self.assert_local_branch(repo, "codex/IGNORED-1", False)
2979
- self.assert_remote_branch(remote, "codex/IGNORED-1", False)
2980
- self.assertFalse(self.registry_manifest_path(repo, "IGNORED-1").exists())
2981
-
2982
- def test_cleanup_safely_deinitializes_submodules_and_preserves_unknown_data(self) -> None:
2983
- root, repo, remote = self.make_repo()
2984
- module = root / "module-source"
2985
- module.mkdir()
2986
- git(module, "init", "-q", "-b", "main")
2987
- git(module, "config", "user.email", "module@example.com")
2988
- git(module, "config", "user.name", "Module Author")
2989
- (module / ".gitignore").write_text(".secret\n.local/\n", encoding="utf-8")
2990
- (module / "module.txt").write_text("module baseline\n", encoding="utf-8")
2991
- git(module, "add", "-A")
2992
- git(module, "commit", "-qm", "module baseline")
2993
-
2994
- git(
2995
- repo,
2996
- "-c",
2997
- "protocol.file.allow=always",
2998
- "submodule",
2999
- "add",
3000
- "-q",
3001
- str(module),
3002
- "vendor/module",
3003
- )
3004
- git(repo, "commit", "-qam", "add submodule")
3005
- git(repo, "push", "-q", "origin", "dev")
3006
- primary_submodule_status = git_output(
3007
- repo,
3008
- "submodule",
3009
- "status",
3010
- "--",
3011
- "vendor/module",
3012
- )
3013
- primary_submodule_url = git_output(repo, "config", "--get", "submodule.vendor/module.url")
3014
- self.assertFalse(primary_submodule_status.startswith("-"))
3015
-
3016
- worktree = self.start_task(repo, "SUBMODULE-1")
3017
- git(
3018
- worktree,
3019
- "-c",
3020
- "protocol.file.allow=always",
3021
- "submodule",
3022
- "update",
3023
- "--init",
3024
- "--recursive",
3025
- )
3026
- (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
3027
- self.commit_push(worktree, "SUBMODULE-1", "SUBMODULE-1: ready")
3028
- self.ap(repo, "task-integrate", "SUBMODULE-1", "--keep-worktree")
3029
-
3030
- task_module = worktree / "vendor" / "module"
3031
- baseline = git_output(task_module, "rev-parse", "HEAD")
3032
-
3033
- extra_worktree = root / "submodule-extra-worktree"
3034
- git(
3035
- task_module,
3036
- "worktree",
3037
- "add",
3038
- "-q",
3039
- "-b",
3040
- "extra-check",
3041
- str(extra_worktree),
3042
- baseline,
3043
- )
3044
- (extra_worktree / "module.txt").write_text("external dirty data\n", encoding="utf-8")
3045
- extra_blocked = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
3046
- self.assertNotEqual(0, extra_blocked.returncode)
3047
- self.assertIn("additional linked worktrees", extra_blocked.stdout + extra_blocked.stderr)
3048
- self.assertEqual(
3049
- "external dirty data\n",
3050
- (extra_worktree / "module.txt").read_text(encoding="utf-8"),
3051
- )
3052
- self.assertEqual("M module.txt", git_output(extra_worktree, "status", "--short"))
3053
- self.assertTrue(worktree.exists())
3054
- self.assert_local_branch(repo, "codex/SUBMODULE-1", True)
3055
-
3056
- (extra_worktree / "module.txt").write_text("module baseline\n", encoding="utf-8")
3057
- git(task_module, "worktree", "remove", str(extra_worktree))
3058
- extra_tip = git_output(task_module, "rev-parse", "refs/heads/extra-check")
3059
- git(task_module, "update-ref", "-d", "refs/heads/extra-check", extra_tip)
3060
-
3061
- git(task_module, "checkout", "-qb", "hidden")
3062
- git(task_module, "config", "user.email", "test@example.com")
3063
- git(task_module, "config", "user.name", "Auto Coding Test")
3064
- (task_module / "hidden.txt").write_text("local-only history\n", encoding="utf-8")
3065
- git(task_module, "add", "hidden.txt")
3066
- git(task_module, "commit", "-qm", "hidden local commit")
3067
- hidden_commit = git_output(task_module, "rev-parse", "HEAD")
3068
- git(task_module, "checkout", "-q", "--detach", baseline)
3069
- self.assertEqual("", git_output(worktree, "status", "--porcelain=v1"))
3070
- self.assertEqual("", git_output(task_module, "status", "--porcelain=v1"))
3071
-
3072
- hidden = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
3073
- self.assertNotEqual(0, hidden.returncode)
3074
- self.assertIn("local refs/reflogs", hidden.stdout + hidden.stderr)
3075
- self.assertEqual(hidden_commit, git_output(task_module, "rev-parse", "refs/heads/hidden"))
3076
- self.assertTrue(worktree.exists())
3077
- self.assert_local_branch(repo, "codex/SUBMODULE-1", True)
3078
-
3079
- git(task_module, "push", "-q", "origin", "refs/heads/hidden:refs/heads/hidden")
3080
- git(
3081
- task_module,
3082
- "fetch",
3083
- "-q",
3084
- "origin",
3085
- "refs/heads/hidden:refs/remotes/origin/hidden",
3086
- )
3087
-
3088
- git(module, "update-ref", "-d", "refs/heads/hidden", hidden_commit)
3089
- git(module, "reflog", "expire", "--expire=now", "--all")
3090
- git(module, "gc", "--prune=now")
3091
- stale = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
3092
- self.assertNotEqual(0, stale.returncode)
3093
- self.assertIn("local refs/reflogs", stale.stdout + stale.stderr)
3094
- self.assertEqual(hidden_commit, git_output(task_module, "rev-parse", "refs/heads/hidden"))
3095
- self.assertTrue(worktree.exists())
3096
-
3097
- git(task_module, "push", "-q", "origin", "refs/heads/hidden:refs/heads/hidden")
3098
- git(
3099
- task_module,
3100
- "fetch",
3101
- "-q",
3102
- "origin",
3103
- "refs/heads/hidden:refs/remotes/origin/hidden",
3104
- )
3105
-
3106
- secret = task_module / ".secret"
3107
- secret.write_text("must survive\n", encoding="utf-8")
3108
- blocked = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
3109
- self.assertNotEqual(0, blocked.returncode)
3110
- self.assertIn("vendor/module/.secret", blocked.stdout + blocked.stderr)
3111
- self.assertEqual("must survive\n", secret.read_text(encoding="utf-8"))
3112
- self.assertTrue(worktree.exists())
3113
- self.assert_local_branch(repo, "codex/SUBMODULE-1", True)
3114
-
3115
- secret.unlink()
3116
- runtime_evidence = (
3117
- worktree / "vendor" / "module" / ".local" / "auto-coding-skill" / "gate.jsonl"
3118
- )
3119
- runtime_evidence.parent.mkdir(parents=True, exist_ok=True)
3120
- runtime_evidence.write_text("disposable runtime data\n", encoding="utf-8")
3121
- self.ap(repo, "task-finish", "SUBMODULE-1")
3122
-
3123
- self.assertFalse(worktree.exists())
3124
- self.assert_local_branch(repo, "codex/SUBMODULE-1", False)
3125
- self.assert_remote_branch(remote, "codex/SUBMODULE-1", False)
3126
- self.assertFalse(self.registry_manifest_path(repo, "SUBMODULE-1").exists())
3127
- self.assertEqual("module baseline\n", (module / "module.txt").read_text(encoding="utf-8"))
3128
- self.assertEqual(
3129
- primary_submodule_status,
3130
- git_output(repo, "submodule", "status", "--", "vendor/module"),
3131
- )
3132
- self.assertEqual(
3133
- primary_submodule_url,
3134
- git_output(repo, "config", "--get", "submodule.vendor/module.url"),
3135
- )
3136
- self.assertEqual("", git_output(repo / "vendor" / "module", "status", "--porcelain=v1"))
3137
-
3138
- git(module, "update-ref", "-d", "refs/heads/hidden", hidden_commit)
3139
- git(module, "reflog", "expire", "--expire=now", "--all")
3140
- git(module, "gc", "--prune=now")
3141
- self.assertNotEqual(
3142
- 0,
3143
- git(module, "cat-file", "-e", f"{hidden_commit}^{{commit}}", check=False).returncode,
3144
- )
3145
- recovery_root = (
3146
- self.registry_manifest_path(repo, "SUBMODULE-1").parents[1]
3147
- / "submodule-recovery"
3148
- )
3149
- recovery_repos = sorted((recovery_root / "repos").glob("*.git"))
3150
- self.assertTrue(recovery_repos)
3151
- self.assertTrue(
3152
- any(
3153
- command(
3154
- repo,
3155
- "git",
3156
- f"--git-dir={candidate}",
3157
- "cat-file",
3158
- "-e",
3159
- f"{hidden_commit}^{{commit}}",
3160
- check=False,
3161
- ).returncode
3162
- == 0
3163
- for candidate in recovery_repos
3164
- ),
3165
- "durable recovery storage must retain submodule commits after remote deletion",
3166
- )
3167
- self.assertTrue(list((recovery_root / "snapshots").rglob("*.json")))
3168
-
3169
- def test_submodule_urls_are_worktree_local_and_common_changes_are_not_overwritten(self) -> None:
3170
- root, repo, _ = self.make_repo()
3171
- module = root / "config-module-source"
3172
- module.mkdir()
3173
- git(module, "init", "-q", "-b", "main")
3174
- git(module, "config", "user.email", "module@example.com")
3175
- git(module, "config", "user.name", "Module Author")
3176
- (module / "module.txt").write_text("module baseline\n", encoding="utf-8")
3177
- git(module, "add", "module.txt")
3178
- git(module, "commit", "-qm", "module baseline")
3179
- module_b = root / "config-module-source-b"
3180
- git(root, "clone", "-q", str(module), str(module_b))
3181
- git(
3182
- repo,
3183
- "-c",
3184
- "protocol.file.allow=always",
3185
- "submodule",
3186
- "add",
3187
- "-q",
3188
- str(module),
3189
- "vendor/module",
3190
- )
3191
- git(repo, "commit", "-qam", "add initially uninitialized submodule")
3192
- git(repo, "push", "-q", "origin", "dev")
3193
- git(repo, "submodule", "-q", "deinit", "-f", "--", "vendor/module")
3194
- git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.url", check=False)
3195
- git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.active", check=False)
3196
- before_status = git_output(repo, "submodule", "status", "--", "vendor/module")
3197
- self.assertTrue(before_status.startswith("-"))
3198
-
3199
- worktree = self.start_task(repo, "SUBMODULE-CONFIG")
3200
- self.assertEqual(
3201
- str(module),
3202
- git_output(worktree, "config", "--worktree", "--get", "submodule.vendor/module.url"),
3203
- )
3204
- gitmodules = worktree / ".gitmodules"
3205
- gitmodules.write_text(
3206
- gitmodules.read_text(encoding="utf-8").replace(str(module), str(module_b)),
3207
- encoding="utf-8",
3208
- )
3209
- git(
3210
- worktree,
3211
- "config",
3212
- "--local",
3213
- "submodule.vendor/module.url",
3214
- str(module_b),
3215
- )
3216
- git(worktree, "config", "--local", "submodule.vendor/module.active", "true")
3217
- conflict = self.ap(worktree, "task-submodule-sync", "SUBMODULE-CONFIG", check=False)
3218
- self.assertNotEqual(0, conflict.returncode)
3219
- self.assertIn("shared submodule config changed", (conflict.stdout + conflict.stderr).lower())
3220
- self.assertEqual(
3221
- str(module_b),
3222
- git_output(repo, "config", "--local", "--get", "submodule.vendor/module.url"),
3223
- )
3224
- git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.url")
3225
- git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.active")
3226
- self.ap(worktree, "task-submodule-sync", "SUBMODULE-CONFIG")
3227
- self.assertEqual(
3228
- str(module_b),
3229
- git_output(worktree, "config", "--worktree", "--get", "submodule.vendor/module.url"),
3230
- )
3231
- self.assertNotEqual(
3232
- 0,
3233
- git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
3234
- )
3235
-
3236
- git(
3237
- worktree,
3238
- "-c",
3239
- "protocol.file.allow=always",
3240
- "submodule",
3241
- "update",
3242
- "--init",
3243
- "--recursive",
3244
- )
3245
- self.assertEqual(
3246
- str(module_b),
3247
- git_output(worktree / "vendor" / "module", "remote", "get-url", "origin"),
3248
- )
3249
- self.assertNotEqual(
3250
- 0,
3251
- git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
3252
- )
3253
- self.assertNotEqual(
3254
- 0,
3255
- git(repo, "config", "--local", "--get", "submodule.vendor/module.active", check=False).returncode,
3256
- )
3257
- (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
3258
- self.commit_push(worktree, "SUBMODULE-CONFIG", "SUBMODULE-CONFIG: ready")
3259
- self.ap(repo, "task-integrate", "SUBMODULE-CONFIG")
3260
-
3261
- self.assertEqual(before_status, git_output(repo, "submodule", "status", "--", "vendor/module"))
3262
- self.assertNotEqual(
3263
- 0,
3264
- git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
3265
- )
3266
-
3267
- def test_relative_submodule_url_uses_task_base_instead_of_control_checkout(self) -> None:
3268
- root, repo, super_remote = self.make_repo()
3269
- module_source = root / "relative-module-source"
3270
- module_source.mkdir()
3271
- git(module_source, "init", "-q", "-b", "main")
3272
- git(module_source, "config", "user.email", "module@example.com")
3273
- git(module_source, "config", "user.name", "Module Author")
3274
- (module_source / "module.txt").write_text("module baseline\n", encoding="utf-8")
3275
- git(module_source, "add", "module.txt")
3276
- git(module_source, "commit", "-qm", "module baseline")
3277
- module_a = root / "module-a.git"
3278
- module_b = root / "module-b.git"
3279
- git(root, "clone", "-q", "--bare", str(module_source), str(module_a))
3280
- git(root, "clone", "-q", "--bare", str(module_source), str(module_b))
3281
-
3282
- git(
3283
- repo,
3284
- "-c",
3285
- "protocol.file.allow=always",
3286
- "submodule",
3287
- "add",
3288
- "-q",
3289
- str(module_a),
3290
- "vendor/module",
3291
- )
3292
- gitmodules = repo / ".gitmodules"
3293
- gitmodules.write_text(
3294
- gitmodules.read_text(encoding="utf-8").replace(str(module_a), "../module-a.git"),
3295
- encoding="utf-8",
3296
- )
3297
- git(repo, "commit", "-qam", "add relative submodule URL")
3298
- git(repo, "push", "-q", "origin", "dev")
3299
- git(repo, "submodule", "-q", "deinit", "-f", "--", "vendor/module")
3300
- git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.url", check=False)
3301
- git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.active", check=False)
3302
-
3303
- git(repo, "branch", "alternate", "dev")
3304
- alternate = root / "alternate-base"
3305
- git(repo, "worktree", "add", "-q", str(alternate), "alternate")
3306
- alternate_gitmodules = alternate / ".gitmodules"
3307
- alternate_gitmodules.write_text(
3308
- alternate_gitmodules.read_text(encoding="utf-8").replace(
3309
- "../module-a.git",
3310
- "../module-b.git",
3311
- ),
3312
- encoding="utf-8",
3313
- )
3314
- git(alternate, "commit", "-qam", "use alternate relative submodule URL")
3315
- git(alternate, "push", "-q", "origin", "alternate")
3316
- git(repo, "worktree", "remove", str(alternate))
3317
- upstream_root = root / "upstream"
3318
- upstream_root.mkdir()
3319
- upstream_super = upstream_root / "super.git"
3320
- git(root, "clone", "-q", "--bare", str(super_remote), str(upstream_super))
3321
- git(repo, "remote", "add", "upstream", str(upstream_super))
3322
-
3323
- self.ap(
3324
- repo,
3325
- "task-start",
3326
- "RELATIVE-BASE",
3327
- "--base",
3328
- "upstream/alternate",
3329
- "--target-branch",
3330
- "alternate",
3331
- "--remote",
3332
- "upstream",
3333
- "--owned-path",
3334
- ".",
3335
- )
3336
- worktree = self.task_worktree(repo, "RELATIVE-BASE")
3337
- self.assertIn("../module-b.git", (worktree / ".gitmodules").read_text(encoding="utf-8"))
3338
- self.assertEqual(
3339
- module_b.resolve(),
3340
- Path(
3341
- git_output(
3342
- worktree,
3343
- "config",
3344
- "--worktree",
3345
- "--get",
3346
- "submodule.vendor/module.url",
3347
- )
3348
- ).resolve(),
3349
- )
3350
- git(
3351
- worktree,
3352
- "-c",
3353
- "protocol.file.allow=always",
3354
- "submodule",
3355
- "update",
3356
- "--init",
3357
- "--recursive",
3358
- )
3359
- self.assertEqual(
3360
- module_b.resolve(),
3361
- Path(
3362
- git_output(worktree / "vendor" / "module", "remote", "get-url", "origin")
3363
- ).resolve(),
3364
- )
3365
- self.assertNotEqual(
3366
- 0,
3367
- git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
3368
- )
3369
-
3370
- def test_cleanup_blocks_deinitialized_residual_submodule_git_history(self) -> None:
3371
- root, repo, remote = self.make_repo()
3372
- for name in ("a", "b"):
3373
- module = root / f"residual-module-{name}"
3374
- module.mkdir()
3375
- git(module, "init", "-q", "-b", "main")
3376
- git(module, "config", "user.email", f"{name}@example.com")
3377
- git(module, "config", "user.name", f"Module {name.upper()}")
3378
- (module / "module.txt").write_text(f"module {name}\n", encoding="utf-8")
3379
- git(module, "add", "module.txt")
3380
- git(module, "commit", "-qm", f"module {name} baseline")
3381
- git(
3382
- repo,
3383
- "-c",
3384
- "protocol.file.allow=always",
3385
- "submodule",
3386
- "add",
3387
- "-q",
3388
- str(module),
3389
- f"vendor/{name}",
3390
- )
3391
- git(repo, "commit", "-qam", "add residual-state submodules")
3392
- git(repo, "push", "-q", "origin", "dev")
3393
-
3394
- worktree = self.start_task(repo, "SUBMODULE-RESIDUAL")
3395
- git(
3396
- worktree,
3397
- "-c",
3398
- "protocol.file.allow=always",
3399
- "submodule",
3400
- "update",
3401
- "--init",
3402
- "--recursive",
3403
- )
3404
- (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
3405
- self.commit_push(worktree, "SUBMODULE-RESIDUAL", "SUBMODULE-RESIDUAL: ready")
3406
- self.ap(repo, "task-integrate", "SUBMODULE-RESIDUAL", "--keep-worktree")
3407
-
3408
- module_b = worktree / "vendor" / "b"
3409
- baseline = git_output(module_b, "rev-parse", "HEAD")
3410
- git(module_b, "config", "user.email", "test@example.com")
3411
- git(module_b, "config", "user.name", "Auto Coding Test")
3412
- git(module_b, "checkout", "-qb", "hidden")
3413
- (module_b / "hidden.txt").write_text("local-only residual history\n", encoding="utf-8")
3414
- git(module_b, "add", "hidden.txt")
3415
- git(module_b, "commit", "-qm", "hidden residual commit")
3416
- hidden_commit = git_output(module_b, "rev-parse", "HEAD")
3417
- module_b_git_dir = Path(git_output(module_b, "rev-parse", "--git-dir"))
3418
- if not module_b_git_dir.is_absolute():
3419
- module_b_git_dir = (module_b / module_b_git_dir).resolve()
3420
- git(module_b, "checkout", "-q", "--detach", baseline)
3421
- git(worktree, "submodule", "-q", "deinit", "-f", "--", "vendor/b")
3422
- module_b_url = git_output(
3423
- repo,
3424
- "config",
3425
- "--file",
3426
- str(repo / ".gitmodules"),
3427
- "--get",
3428
- "submodule.vendor/b.url",
3429
- )
3430
- git(repo, "config", "--local", "submodule.vendor/b.url", module_b_url)
3431
- git(repo, "config", "--local", "submodule.vendor/b.active", "true")
3432
- self.assertFalse((worktree / "vendor" / "b" / ".git").exists())
3433
- self.assertEqual(
3434
- hidden_commit,
3435
- command(
3436
- repo,
3437
- "git",
3438
- f"--git-dir={module_b_git_dir}",
3439
- "rev-parse",
3440
- "refs/heads/hidden",
3441
- ).stdout.strip(),
3442
- )
3443
-
3444
- blocked = self.ap(repo, "task-finish", "SUBMODULE-RESIDUAL", check=False)
3445
- self.assertNotEqual(0, blocked.returncode)
3446
- self.assertIn("residual module Git directory", blocked.stdout + blocked.stderr)
3447
- self.assertTrue(worktree.exists())
3448
- self.assertTrue(module_b_git_dir.exists())
3449
- self.assertEqual(
3450
- hidden_commit,
3451
- command(
3452
- repo,
3453
- "git",
3454
- f"--git-dir={module_b_git_dir}",
3455
- "rev-parse",
3456
- "refs/heads/hidden",
3457
- ).stdout.strip(),
3458
- )
3459
- self.assert_local_branch(repo, "codex/SUBMODULE-RESIDUAL", True)
3460
- self.assert_remote_branch(remote, "codex/SUBMODULE-RESIDUAL", True)
3461
- self.assertTrue(self.registry_manifest_path(repo, "SUBMODULE-RESIDUAL").exists())
3462
- self.assertTrue((worktree / "vendor" / "a" / ".git").exists())
3463
-
3464
- def test_changed_remote_task_branch_stays_cleanup_pending_until_safe_retry(self) -> None:
3465
- root, repo, remote = self.make_repo()
3466
- worktree = self.start_task(repo, "REMOTE-RACE")
3467
- (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
3468
- self.commit_push(worktree, "REMOTE-RACE", "REMOTE-RACE: ready")
3469
- review_dir = Path(
3470
- json.loads(
3471
- self.registry_manifest_path(repo, "REMOTE-RACE").read_text(encoding="utf-8")
3472
- )["review"]["assignment_path"]
3473
- ).parent
3474
- self.ap(repo, "task-integrate", "REMOTE-RACE", "--keep-worktree")
3475
-
3476
- attacker = root / "attacker"
3477
- git(root, "clone", "-q", str(remote), str(attacker))
3478
- git(attacker, "config", "user.email", "other@example.com")
3479
- git(attacker, "config", "user.name", "Other Writer")
3480
- git(attacker, "checkout", "-qb", "remote-race", "origin/codex/REMOTE-RACE")
3481
- (attacker / "other.txt").write_text("other writer\n", encoding="utf-8")
3482
- git(attacker, "add", "other.txt")
3483
- git(attacker, "commit", "-qm", "other writer advances task branch")
3484
- git(attacker, "push", "-q", "origin", "HEAD:refs/heads/codex/REMOTE-RACE")
3485
- changed_remote_tip = git_output(remote, "rev-parse", "refs/heads/codex/REMOTE-RACE")
3486
-
3487
- finish = self.ap(repo, "task-finish", "REMOTE-RACE")
3488
- self.assertIn("remote_branch_deleted=false", finish.stdout + finish.stderr)
3489
- self.assertFalse(worktree.exists())
3490
- self.assert_local_branch(repo, "codex/REMOTE-RACE", False)
3491
- self.assertEqual(
3492
- changed_remote_tip,
3493
- git_output(remote, "rev-parse", "refs/heads/codex/REMOTE-RACE"),
3494
- )
3495
- manifest_path = self.registry_manifest_path(repo, "REMOTE-RACE")
3496
- manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
3497
- self.assertEqual("cleanup-pending", manifest["state"])
3498
- self.assertTrue(review_dir.is_dir())
3499
-
3500
- prune = self.ap(repo, "task-prune")
3501
- self.assertIn("remote cleanup pending", prune.stdout + prune.stderr)
3502
- self.assertTrue(manifest_path.exists())
3503
- self.assert_remote_branch(remote, "codex/REMOTE-RACE", True)
3504
-
3505
- git(remote, "update-ref", "-d", "refs/heads/codex/REMOTE-RACE", changed_remote_tip)
3506
- self.ap(repo, "task-prune")
3507
- self.assertFalse(manifest_path.exists())
3508
- self.assertFalse(review_dir.exists())
3509
- self.assert_remote_branch(remote, "codex/REMOTE-RACE", False)
3510
-
3511
- def test_gate_mutation_aborts_before_staging_or_commit(self) -> None:
3512
- _, repo, remote = self.make_repo()
3513
- self.update_config(
3514
- repo,
3515
- lambda config: config["commands"].update(
3516
- {"gate_changed": "printf gate-change >> shared.txt"}
3517
- ),
3518
- )
3519
- worktree = self.start_task(repo, "MUTATE-1")
3520
- before = git_output(worktree, "rev-parse", "HEAD")
3521
- (worktree / "task.txt").write_text("task\n", encoding="utf-8")
3522
- self.approve_task(worktree, "MUTATE-1")
3523
-
3524
- result = self.ap(
3525
- worktree,
3526
- "commit-push",
3527
- "MUTATE-1",
3528
- "--msg",
3529
- "MUTATE-1: must abort",
3530
- check=False,
3531
- )
3532
-
3533
- self.assertNotEqual(0, result.returncode)
3534
- self.assertIn("gate changed", (result.stdout + result.stderr).lower())
3535
- self.assertEqual(before, git_output(worktree, "rev-parse", "HEAD"))
3536
- self.assertEqual("", git_output(worktree, "diff", "--cached", "--name-only"))
3537
- self.assert_remote_branch(remote, "codex/MUTATE-1", False)
3538
-
3539
- def test_post_commit_hook_mutation_prevents_push(self) -> None:
3540
- _, repo, remote = self.make_repo()
3541
- worktree = self.start_task(repo, "COMMIT-HOOK")
3542
- self.install_hook(
3543
- repo,
3544
- "post-commit",
3545
- 'root="$(git rev-parse --show-toplevel)"\n'
3546
- 'printf "hook mutation\\n" > "$root/hook-after.txt"\n',
3547
- )
3548
- before = git_output(worktree, "rev-parse", "HEAD")
3549
- (worktree / "payload.txt").write_text("payload\n", encoding="utf-8")
3550
- self.approve_task(worktree, "COMMIT-HOOK")
3551
-
3552
- result = self.ap(
3553
- worktree,
3554
- "commit-push",
3555
- "COMMIT-HOOK",
3556
- "--msg",
3557
- "COMMIT-HOOK: must stay local",
3558
- check=False,
3559
- )
3560
-
3561
- self.assertNotEqual(0, result.returncode)
3562
- self.assertIn("not pushed", (result.stdout + result.stderr).lower())
3563
- self.assertNotEqual(before, git_output(worktree, "rev-parse", "HEAD"))
3564
- self.assertEqual("hook mutation\n", (worktree / "hook-after.txt").read_text(encoding="utf-8"))
3565
- self.assert_remote_branch(remote, "codex/COMMIT-HOOK", False)
3566
-
3567
- def test_missing_config_defaults_to_worktree_and_legacy_is_rejected(self) -> None:
3568
- _, default_repo, _ = self.make_repo(_MISSING)
3569
- (default_repo / "shared.txt").write_text("must stay isolated\n", encoding="utf-8")
3570
- default_commit = self.assert_rejected_without_mutation(
3571
- default_repo,
3572
- "commit-push",
3573
- "DEFAULT-1",
3574
- "--msg",
3575
- "DEFAULT-1: must start first",
3576
- )
3577
- self.assertIn("task-start", (default_commit.stdout + default_commit.stderr).lower())
3578
- default_repo.joinpath("shared.txt").write_text("baseline\n", encoding="utf-8")
3579
- self.start_task(default_repo, "DEFAULT-1")
3580
-
3581
- _, legacy_repo, legacy_remote = self.make_repo("legacy")
3582
- before = git_output(legacy_repo, "rev-parse", "HEAD")
3583
- (legacy_repo / "shared.txt").write_text("legacy shared checkout\n", encoding="utf-8")
3584
- result = self.ap(
3585
- legacy_repo,
3586
- "commit-push",
3587
- "LEGACY-1",
3588
- "--msg",
3589
- "LEGACY-1: must be rejected",
3590
- check=False,
3591
- )
3592
- self.assertNotEqual(0, result.returncode)
3593
- self.assertIn("must be adaptive or worktree", result.stdout + result.stderr)
3594
- self.assertEqual(before, git_output(legacy_repo, "rev-parse", "HEAD"))
3595
- self.assertEqual(
3596
- "baseline",
3597
- git_output(legacy_remote, "show", "refs/heads/dev:shared.txt"),
3598
- )
3599
-
3600
-
3601
- if __name__ == "__main__":
3602
- unittest.main()