@elvis1513/auto-coding-skill 2.2.1 → 3.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.
@@ -0,0 +1,1578 @@
1
+ #!/usr/bin/env python3
2
+ from __future__ import annotations
3
+
4
+ import json
5
+ import os
6
+ import subprocess
7
+ import sys
8
+ import tempfile
9
+ import unittest
10
+ from concurrent.futures import ThreadPoolExecutor
11
+ from pathlib import Path
12
+
13
+ import yaml
14
+
15
+
16
+ REPO_ROOT = Path(__file__).resolve().parents[2]
17
+ AP_SCRIPT = REPO_ROOT / "src" / "auto-coding-skill" / "scripts" / "ap.py"
18
+ _MISSING = object()
19
+
20
+
21
+ def command(
22
+ cwd: Path,
23
+ *args: str,
24
+ check: bool = True,
25
+ input_text: str | None = None,
26
+ ) -> subprocess.CompletedProcess[str]:
27
+ result = subprocess.run(
28
+ list(args),
29
+ cwd=cwd,
30
+ check=False,
31
+ text=True,
32
+ input=input_text,
33
+ capture_output=True,
34
+ timeout=30,
35
+ )
36
+ if check and result.returncode != 0:
37
+ raise AssertionError(
38
+ f"command failed ({result.returncode}): {' '.join(args)}\n"
39
+ f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
40
+ )
41
+ return result
42
+
43
+
44
+ def git(cwd: Path, *args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
45
+ return command(cwd, "git", *args, check=check)
46
+
47
+
48
+ def git_output(cwd: Path, *args: str) -> str:
49
+ return git(cwd, *args).stdout.strip()
50
+
51
+
52
+ def base_config(isolation: str | object = "worktree") -> dict:
53
+ config = {
54
+ "workflow": {"mode": "dev", "profile": "auto", "completion": "push"},
55
+ "project": {"name": "concurrency-test"},
56
+ "access": {
57
+ "project": {
58
+ "frontend": {"url": "https://project-front.test", "username": "front", "password": "front-pass"},
59
+ "backend": {"url": "https://project-back.test", "username": "back", "password": "back-pass"},
60
+ },
61
+ "jenkins": {
62
+ "frontend": {"url": "https://jenkins-front.test", "username": "front", "password": "front-pass"},
63
+ "backend": {"url": "https://jenkins-back.test", "username": "back", "password": "back-pass"},
64
+ },
65
+ "gitlab": {"url": "https://gitlab.test", "username": "git", "password": "git-pass"},
66
+ "nexus": {
67
+ "frontend": {"url": "https://nexus.test", "username": "nexus", "password": "nexus-pass"},
68
+ },
69
+ },
70
+ "commands": {
71
+ "gate_changed": "true",
72
+ "gate_standard": "true",
73
+ "gate_full": "true",
74
+ },
75
+ "gate": {
76
+ "default_scope": "auto",
77
+ "fallback_scope": "standard",
78
+ "full_on_unknown": True,
79
+ "no_change_scope": "standard",
80
+ "rules": [],
81
+ },
82
+ "structure": {"enabled": False, "enforcement": "advisory"},
83
+ "verification": {
84
+ "target_env_required": False,
85
+ "jenkins_required": False,
86
+ },
87
+ "docs": {
88
+ "taskbook": "docs/tasks/taskbook.md",
89
+ "closure_log": "docs/tasks/closure-log.md",
90
+ "evidence_log": "docs/tasks/evidence.jsonl",
91
+ "design_dir": "docs/design",
92
+ "ledger_check_enabled": False,
93
+ },
94
+ }
95
+ if isolation is not _MISSING:
96
+ config["concurrency"] = {
97
+ "isolation": isolation,
98
+ "base_ref": "origin/dev",
99
+ "target_branch": "dev",
100
+ "branch_prefix": "codex/",
101
+ # Tests replace this with an absolute path outside the primary checkout.
102
+ "worktree_root": "",
103
+ "cleanup_merged": True,
104
+ "delete_remote_branch": True,
105
+ }
106
+ return config
107
+
108
+
109
+ class AutoCodingConcurrencyTests(unittest.TestCase):
110
+ def make_repo(
111
+ self,
112
+ isolation: str | object = "worktree",
113
+ ) -> tuple[Path, Path, Path]:
114
+ temp = tempfile.TemporaryDirectory(prefix="autocoding-concurrency-")
115
+ self.addCleanup(temp.cleanup)
116
+ root = Path(temp.name)
117
+ repo = root / "project"
118
+ remote = root / "origin.git"
119
+ worktrees = root / "worktrees"
120
+ repo.mkdir()
121
+
122
+ git(root, "init", "--bare", "-q", str(remote))
123
+ git(repo, "init", "-q", "-b", "dev")
124
+ git(repo, "config", "user.email", "test@example.com")
125
+ git(repo, "config", "user.name", "Auto Coding Test")
126
+
127
+ config = base_config(isolation)
128
+ if "concurrency" in config:
129
+ config["concurrency"]["worktree_root"] = str(worktrees)
130
+ engineering = repo / "docs" / "ENGINEERING.md"
131
+ engineering.parent.mkdir(parents=True)
132
+ engineering.write_text(
133
+ "---\n"
134
+ + yaml.safe_dump(config, allow_unicode=True, sort_keys=False)
135
+ + "---\n# Engineering\n",
136
+ encoding="utf-8",
137
+ )
138
+ tasks = repo / "docs" / "tasks"
139
+ tasks.mkdir(parents=True)
140
+ (tasks / "taskbook.md").write_text("# Taskbook\n", encoding="utf-8")
141
+ (tasks / "closure-log.md").write_text("# Closure Log\n", encoding="utf-8")
142
+ (repo / "shared.txt").write_text("baseline\n", encoding="utf-8")
143
+ git(repo, "add", "-A")
144
+ git(repo, "commit", "-qm", "baseline")
145
+ git(repo, "remote", "add", "origin", str(remote))
146
+ git(repo, "push", "-qu", "origin", "dev")
147
+ git(remote, "symbolic-ref", "HEAD", "refs/heads/dev")
148
+ return root, repo, remote
149
+
150
+ def ap(
151
+ self,
152
+ repo: Path,
153
+ *args: str,
154
+ check: bool = True,
155
+ ) -> subprocess.CompletedProcess[str]:
156
+ return command(
157
+ repo,
158
+ sys.executable,
159
+ str(AP_SCRIPT),
160
+ "--repo",
161
+ str(repo),
162
+ *args,
163
+ check=check,
164
+ )
165
+
166
+ def approve_task(self, repo: Path, task_id: str) -> str:
167
+ status = self.ap(repo, "task-status", task_id, "--json")
168
+ fingerprint = json.loads(status.stdout)["tasks"][0]["current_diff_fingerprint"]
169
+ self.ap(
170
+ repo,
171
+ "task-review",
172
+ task_id,
173
+ "--verdict",
174
+ "approved",
175
+ "--diff-fingerprint",
176
+ fingerprint,
177
+ "--reviewer",
178
+ "test-reviewer",
179
+ )
180
+ return fingerprint
181
+
182
+ def commit_push(self, repo: Path, task_id: str, message: str) -> subprocess.CompletedProcess[str]:
183
+ self.approve_task(repo, task_id)
184
+ return self.ap(repo, "commit-push", task_id, "--msg", message)
185
+
186
+ def task_worktree(self, repo: Path, task_id: str) -> Path:
187
+ wanted = f"refs/heads/codex/{task_id}"
188
+ current_path: Path | None = None
189
+ for line in git_output(repo, "worktree", "list", "--porcelain").splitlines():
190
+ if line.startswith("worktree "):
191
+ current_path = Path(line.removeprefix("worktree "))
192
+ elif line == f"branch {wanted}" and current_path is not None:
193
+ return current_path
194
+ self.fail(f"no worktree registered for {wanted}")
195
+
196
+ def start_task(self, repo: Path, task_id: str) -> Path:
197
+ result = self.ap(
198
+ repo,
199
+ "task-start",
200
+ task_id,
201
+ "--base",
202
+ "origin/dev",
203
+ "--owned-path",
204
+ ".",
205
+ )
206
+ worktree = self.task_worktree(repo, task_id)
207
+ self.assertIn(task_id, result.stdout + result.stderr)
208
+ self.assertTrue(worktree.is_dir())
209
+ self.assertNotEqual(repo.resolve(), worktree.resolve())
210
+ self.assertNotIn(repo.resolve(), worktree.resolve().parents)
211
+ self.assertEqual(f"codex/{task_id}", git_output(worktree, "branch", "--show-current"))
212
+ return worktree
213
+
214
+ def assert_local_branch(self, repo: Path, branch: str, exists: bool) -> None:
215
+ result = git(repo, "show-ref", "--verify", "--quiet", f"refs/heads/{branch}", check=False)
216
+ self.assertEqual(exists, result.returncode == 0, branch)
217
+
218
+ def assert_remote_branch(self, remote: Path, branch: str, exists: bool) -> None:
219
+ result = git(
220
+ remote,
221
+ "show-ref",
222
+ "--verify",
223
+ "--quiet",
224
+ f"refs/heads/{branch}",
225
+ check=False,
226
+ )
227
+ self.assertEqual(exists, result.returncode == 0, branch)
228
+
229
+ def assert_rejected_without_mutation(
230
+ self,
231
+ repo: Path,
232
+ *args: str,
233
+ ) -> subprocess.CompletedProcess[str]:
234
+ before_head = git_output(repo, "rev-parse", "HEAD")
235
+ before_status = git_output(repo, "status", "--porcelain=v1", "--untracked-files=all")
236
+ result = self.ap(repo, *args, check=False)
237
+ self.assertNotEqual(0, result.returncode, result.stdout + result.stderr)
238
+ self.assertEqual(before_head, git_output(repo, "rev-parse", "HEAD"))
239
+ self.assertEqual(
240
+ before_status,
241
+ git_output(repo, "status", "--porcelain=v1", "--untracked-files=all"),
242
+ )
243
+ return result
244
+
245
+ def manifest_payloads(self, repo: Path) -> list[dict]:
246
+ common_dir_raw = git_output(repo, "rev-parse", "--git-common-dir")
247
+ common_dir = Path(common_dir_raw)
248
+ if not common_dir.is_absolute():
249
+ common_dir = (repo / common_dir).resolve()
250
+ payloads: list[dict] = []
251
+ for candidate in common_dir.rglob("*.json"):
252
+ try:
253
+ payload = json.loads(candidate.read_text(encoding="utf-8"))
254
+ except (OSError, UnicodeDecodeError, json.JSONDecodeError):
255
+ continue
256
+ if isinstance(payload, dict):
257
+ payloads.append(payload)
258
+ return payloads
259
+
260
+ def registry_manifest_path(self, repo: Path, task_id: str) -> Path:
261
+ common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
262
+ if not common_dir.is_absolute():
263
+ common_dir = (repo / common_dir).resolve()
264
+ return common_dir / "auto-coding-skill" / "tasks" / f"{task_id}.json"
265
+
266
+ def install_hook(self, repo: Path, name: str, body: str) -> Path:
267
+ common_dir = Path(git_output(repo, "rev-parse", "--git-common-dir"))
268
+ if not common_dir.is_absolute():
269
+ common_dir = (repo / common_dir).resolve()
270
+ hook = common_dir / "hooks" / name
271
+ hook.write_text("#!/bin/sh\nset -eu\n" + body, encoding="utf-8")
272
+ hook.chmod(0o755)
273
+ return hook
274
+
275
+ def test_task_start_creates_external_worktree_manifest_and_status(self) -> None:
276
+ _, repo, _ = self.make_repo()
277
+ worktree = self.start_task(repo, "START-1")
278
+
279
+ status = self.ap(repo, "task-status", "START-1")
280
+ rendered_status = status.stdout + status.stderr
281
+ self.assertIn("START-1", rendered_status)
282
+ self.assertIn("codex/START-1", rendered_status)
283
+ self.assertIn(str(worktree), rendered_status)
284
+
285
+ serialized_payloads = [json.dumps(item, sort_keys=True) for item in self.manifest_payloads(repo)]
286
+ self.assertTrue(
287
+ any(
288
+ "START-1" in payload
289
+ and "codex/START-1" in payload
290
+ and str(worktree) in payload
291
+ for payload in serialized_payloads
292
+ ),
293
+ "task-start must persist a task manifest in the Git common directory",
294
+ )
295
+ active_task = (worktree / "docs" / "tasks" / "active" / "START-1.md").read_text(
296
+ encoding="utf-8"
297
+ )
298
+ for field in [
299
+ "Worktree:",
300
+ "Orchestrator:",
301
+ "Owning fixer:",
302
+ "Owned paths:",
303
+ "Depends on integrated tasks:",
304
+ "Reviewer / stable diff:",
305
+ "Review verdict:",
306
+ ]:
307
+ self.assertIn(field, active_task)
308
+
309
+ def test_schema_one_task_status_fails_closed_with_migration_recovery(self) -> None:
310
+ _, repo, _ = self.make_repo()
311
+ self.start_task(repo, "LEGACY-SCHEMA")
312
+ registry = self.registry_manifest_path(repo, "LEGACY-SCHEMA")
313
+ payload = json.loads(registry.read_text(encoding="utf-8"))
314
+ payload["schema"] = 1
315
+ for field in [
316
+ "owned_paths",
317
+ "depends_on",
318
+ "prerequisite_shas",
319
+ "writer_lease",
320
+ "review",
321
+ ]:
322
+ payload.pop(field, None)
323
+ registry.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
324
+
325
+ result = self.ap(repo, "task-status", "LEGACY-SCHEMA", check=False)
326
+ rendered = result.stdout + result.stderr
327
+ self.assertNotEqual(0, result.returncode)
328
+ self.assertIn("legacy schema-1 task", rendered)
329
+ self.assertIn("cannot safely infer or claim owned_paths", rendered)
330
+ self.assertIn("previously installed runtime", rendered)
331
+ self.assertIn("restore the 3.0.0 runtime", rendered)
332
+
333
+ def test_owned_paths_are_required_and_unowned_changes_are_rejected(self) -> None:
334
+ _, repo, remote = self.make_repo()
335
+ missing = self.ap(
336
+ repo,
337
+ "task-start",
338
+ "NO-OWNED",
339
+ "--base",
340
+ "origin/dev",
341
+ check=False,
342
+ )
343
+ self.assertNotEqual(0, missing.returncode)
344
+ self.assertIn("owned-path", (missing.stdout + missing.stderr).lower())
345
+ self.assert_remote_branch(remote, "codex/NO-OWNED", False)
346
+
347
+ self.ap(
348
+ repo,
349
+ "task-start",
350
+ "OWNED-ONLY",
351
+ "--base",
352
+ "origin/dev",
353
+ "--owned-path",
354
+ "src/owned",
355
+ )
356
+ worktree = self.task_worktree(repo, "OWNED-ONLY")
357
+ outside = worktree / "src" / "outside.txt"
358
+ outside.parent.mkdir(parents=True)
359
+ outside.write_text("outside\n", encoding="utf-8")
360
+ status = self.ap(worktree, "task-status", "OWNED-ONLY", "--json")
361
+ fingerprint = json.loads(status.stdout)["tasks"][0]["current_diff_fingerprint"]
362
+ review = self.ap(
363
+ worktree,
364
+ "task-review",
365
+ "OWNED-ONLY",
366
+ "--verdict",
367
+ "approved",
368
+ "--diff-fingerprint",
369
+ fingerprint,
370
+ check=False,
371
+ )
372
+ self.assertNotEqual(0, review.returncode)
373
+ self.assertIn("outside task owned_paths", review.stdout + review.stderr)
374
+
375
+ def test_approved_fingerprint_expires_when_owned_diff_changes(self) -> None:
376
+ _, repo, remote = self.make_repo()
377
+ worktree = self.start_task(repo, "STALE-REVIEW")
378
+ payload = worktree / "payload.txt"
379
+ payload.write_text("reviewed\n", encoding="utf-8")
380
+ registry = self.registry_manifest_path(repo, "STALE-REVIEW")
381
+ manifest = json.loads(registry.read_text(encoding="utf-8"))
382
+ owner = manifest["owner"]
383
+ manifest["owner"] = "another-lifecycle-owner"
384
+ registry.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
385
+ status = self.ap(worktree, "task-status", "STALE-REVIEW", "--json")
386
+ fingerprint = json.loads(status.stdout)["tasks"][0]["current_diff_fingerprint"]
387
+ non_owner_review = self.ap(
388
+ worktree,
389
+ "task-review",
390
+ "STALE-REVIEW",
391
+ "--verdict",
392
+ "approved",
393
+ "--diff-fingerprint",
394
+ fingerprint,
395
+ check=False,
396
+ )
397
+ self.assertNotEqual(0, non_owner_review.returncode)
398
+ self.assertIn("lifecycle owner", non_owner_review.stdout + non_owner_review.stderr)
399
+ manifest["owner"] = owner
400
+ registry.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
401
+ self.approve_task(worktree, "STALE-REVIEW")
402
+ payload.write_text("changed after review\n", encoding="utf-8")
403
+
404
+ result = self.ap(
405
+ worktree,
406
+ "commit-push",
407
+ "STALE-REVIEW",
408
+ "--msg",
409
+ "STALE-REVIEW: must fail",
410
+ check=False,
411
+ )
412
+ self.assertNotEqual(0, result.returncode)
413
+ self.assertIn("fingerprint is stale", result.stdout + result.stderr)
414
+ self.assert_remote_branch(remote, "codex/STALE-REVIEW", False)
415
+
416
+ def test_writer_lease_requires_match_and_owner_handoff_uses_generation_cas(self) -> None:
417
+ _, repo, _ = self.make_repo()
418
+ owner = os.environ["CODEX_THREAD_ID"]
419
+ self.ap(
420
+ repo,
421
+ "task-start",
422
+ "LEASE-1",
423
+ "--base",
424
+ "origin/dev",
425
+ "--owned-path",
426
+ ".",
427
+ "--writer",
428
+ "fixer-label",
429
+ )
430
+ worktree = self.task_worktree(repo, "LEASE-1")
431
+ (worktree / "lease.txt").write_text("ready\n", encoding="utf-8")
432
+ self.approve_task(worktree, "LEASE-1")
433
+
434
+ mismatch = self.ap(
435
+ worktree,
436
+ "commit-push",
437
+ "LEASE-1",
438
+ "--msg",
439
+ "LEASE-1: wrong writer",
440
+ check=False,
441
+ )
442
+ self.assertNotEqual(0, mismatch.returncode)
443
+ self.assertIn("writer lease mismatch", (mismatch.stdout + mismatch.stderr).lower())
444
+
445
+ spoofed = self.ap(
446
+ worktree,
447
+ "commit-push",
448
+ "LEASE-1",
449
+ "--msg",
450
+ "LEASE-1: spoofed writer",
451
+ "--writer",
452
+ "fixer-label",
453
+ check=False,
454
+ )
455
+ self.assertNotEqual(0, spoofed.returncode)
456
+ self.assertIn("actor identity cannot be overridden", spoofed.stdout + spoofed.stderr)
457
+
458
+ self.ap(
459
+ repo,
460
+ "task-handoff",
461
+ "LEASE-1",
462
+ "--from",
463
+ "fixer-label",
464
+ "--to",
465
+ owner,
466
+ "--generation",
467
+ "1",
468
+ )
469
+ stale = self.ap(
470
+ repo,
471
+ "task-handoff",
472
+ "LEASE-1",
473
+ "--from",
474
+ owner,
475
+ "--to",
476
+ "next-writer",
477
+ "--generation",
478
+ "1",
479
+ check=False,
480
+ )
481
+ self.assertNotEqual(0, stale.returncode)
482
+ self.assertIn("generation changed", stale.stdout + stale.stderr)
483
+ manifest = json.loads(self.registry_manifest_path(repo, "LEASE-1").read_text(encoding="utf-8"))
484
+ self.assertEqual(owner, manifest["writer_lease"]["holder"])
485
+ self.assertEqual(2, manifest["writer_lease"]["generation"])
486
+
487
+ def test_dependency_sha_must_already_be_in_task_base(self) -> None:
488
+ _, repo, _ = self.make_repo()
489
+ tree = git_output(repo, "rev-parse", "HEAD^{tree}")
490
+ orphan = git_output(repo, "commit-tree", tree, "-m", "unintegrated prerequisite")
491
+ result = self.ap(
492
+ repo,
493
+ "task-start",
494
+ "DEPENDENT-1",
495
+ "--base",
496
+ "origin/dev",
497
+ "--owned-path",
498
+ ".",
499
+ "--depends-on",
500
+ f"UPSTREAM-1={orphan}",
501
+ check=False,
502
+ )
503
+ self.assertNotEqual(0, result.returncode)
504
+ self.assertIn("not integrated", result.stdout + result.stderr)
505
+
506
+ def test_target_advance_rebases_then_requires_review_before_integration(self) -> None:
507
+ _, repo, remote = self.make_repo()
508
+ worktree = self.start_task(repo, "REBASE-REVIEW")
509
+ (worktree / "task.txt").write_text("task\n", encoding="utf-8")
510
+ self.commit_push(worktree, "REBASE-REVIEW", "REBASE-REVIEW: ready")
511
+
512
+ (repo / "upstream.txt").write_text("upstream\n", encoding="utf-8")
513
+ git(repo, "add", "upstream.txt")
514
+ git(repo, "commit", "-qm", "advance target")
515
+ git(repo, "push", "-q", "origin", "dev")
516
+
517
+ rebased = self.ap(repo, "task-integrate", "REBASE-REVIEW", check=False)
518
+ self.assertNotEqual(0, rebased.returncode)
519
+ self.assertIn("review again", rebased.stdout + rebased.stderr)
520
+ manifest = json.loads(self.registry_manifest_path(repo, "REBASE-REVIEW").read_text(encoding="utf-8"))
521
+ self.assertEqual("pushed", manifest["state"])
522
+ self.assertEqual("pending", manifest["review"]["verdict"])
523
+ self.assertNotEqual(
524
+ 0,
525
+ git(remote, "cat-file", "-e", "refs/heads/dev:task.txt", check=False).returncode,
526
+ )
527
+
528
+ self.approve_task(worktree, "REBASE-REVIEW")
529
+ self.ap(repo, "task-integrate", "REBASE-REVIEW")
530
+ self.assertEqual("task", git_output(remote, "show", "refs/heads/dev:task.txt"))
531
+
532
+ def test_rebase_conflict_can_resume_only_then_requires_fresh_review(self) -> None:
533
+ _, repo, remote = self.make_repo()
534
+ worktree = self.start_task(repo, "RESUME-1")
535
+ (worktree / "shared.txt").write_text("task side\n", encoding="utf-8")
536
+ self.commit_push(worktree, "RESUME-1", "RESUME-1: ready")
537
+
538
+ (repo / "shared.txt").write_text("target side\n", encoding="utf-8")
539
+ git(repo, "add", "shared.txt")
540
+ git(repo, "commit", "-qm", "conflicting target change")
541
+ git(repo, "push", "-q", "origin", "dev")
542
+
543
+ conflict = self.ap(repo, "task-integrate", "RESUME-1", check=False)
544
+ self.assertNotEqual(0, conflict.returncode)
545
+ self.assertIn("rebase conflicted", conflict.stdout + conflict.stderr)
546
+ manifest = json.loads(self.registry_manifest_path(repo, "RESUME-1").read_text(encoding="utf-8"))
547
+ self.assertEqual("conflicted", manifest["state"])
548
+ self.assertEqual("pending", manifest["review"]["verdict"])
549
+
550
+ (worktree / "shared.txt").write_text("resolved\n", encoding="utf-8")
551
+ git(worktree, "add", "shared.txt")
552
+ git(worktree, "-c", "core.editor=true", "rebase", "--continue")
553
+ self.ap(repo, "task-resume", "RESUME-1")
554
+ manifest = json.loads(self.registry_manifest_path(repo, "RESUME-1").read_text(encoding="utf-8"))
555
+ self.assertEqual("pushed", manifest["state"])
556
+ self.assertEqual("pending", manifest["review"]["verdict"])
557
+
558
+ self.approve_task(worktree, "RESUME-1")
559
+ self.ap(repo, "task-integrate", "RESUME-1")
560
+ self.assertEqual("resolved", git_output(remote, "show", "refs/heads/dev:shared.txt"))
561
+
562
+ def test_task_start_rolls_back_checkout_hook_side_effects(self) -> None:
563
+ hook_bodies = {
564
+ "untracked": (
565
+ 'root="$(git rev-parse --show-toplevel)"\n'
566
+ 'printf "hook data\\n" > "$root/hook-created.txt"\n'
567
+ ),
568
+ "clean-commit": (
569
+ 'root="$(git rev-parse --show-toplevel)"\n'
570
+ 'printf "hook commit\\n" > "$root/hook-created.txt"\n'
571
+ 'git -C "$root" add hook-created.txt\n'
572
+ 'git -C "$root" commit --no-verify -qm "checkout hook commit"\n'
573
+ ),
574
+ }
575
+ for label, body in hook_bodies.items():
576
+ with self.subTest(label=label):
577
+ root, repo, _ = self.make_repo()
578
+ self.install_hook(repo, "post-checkout", body)
579
+ task_id = f"HOOK-{label.upper()}"
580
+
581
+ result = self.ap(
582
+ repo,
583
+ "task-start",
584
+ task_id,
585
+ "--base",
586
+ "origin/dev",
587
+ "--owned-path",
588
+ ".",
589
+ check=False,
590
+ )
591
+
592
+ self.assertNotEqual(0, result.returncode)
593
+ self.assertIn("hook", (result.stdout + result.stderr).lower())
594
+ self.assert_local_branch(repo, f"codex/{task_id}", False)
595
+ self.assertFalse(self.registry_manifest_path(repo, task_id).exists())
596
+ self.assertNotIn(
597
+ f"refs/heads/codex/{task_id}",
598
+ git_output(repo, "worktree", "list", "--porcelain"),
599
+ )
600
+ self.assertFalse((root / "worktrees" / repo.name / task_id).exists())
601
+
602
+ def test_control_commands_are_rejected_from_another_task_worktree(self) -> None:
603
+ _, repo, _ = self.make_repo()
604
+ first = self.start_task(repo, "CROSS-1")
605
+ second = self.start_task(repo, "CROSS-2")
606
+
607
+ commands = [
608
+ ("task-integrate", "CROSS-1"),
609
+ ("task-finish", "CROSS-1"),
610
+ ("task-prune",),
611
+ ("task-start", "CROSS-3"),
612
+ ]
613
+ for args in commands:
614
+ with self.subTest(command=args[0]):
615
+ before = {
616
+ "control_head": git_output(repo, "rev-parse", "HEAD"),
617
+ "control_status": git_output(repo, "status", "--porcelain=v1"),
618
+ "first_head": git_output(first, "rev-parse", "HEAD"),
619
+ "first_status": git_output(first, "status", "--porcelain=v1"),
620
+ "second_head": git_output(second, "rev-parse", "HEAD"),
621
+ "second_status": git_output(second, "status", "--porcelain=v1"),
622
+ "worktrees": git_output(repo, "worktree", "list", "--porcelain"),
623
+ }
624
+ result = self.ap(second, *args, check=False)
625
+ self.assertNotEqual(0, result.returncode)
626
+ self.assertIn("control", (result.stdout + result.stderr).lower())
627
+ after = {
628
+ "control_head": git_output(repo, "rev-parse", "HEAD"),
629
+ "control_status": git_output(repo, "status", "--porcelain=v1"),
630
+ "first_head": git_output(first, "rev-parse", "HEAD"),
631
+ "first_status": git_output(first, "status", "--porcelain=v1"),
632
+ "second_head": git_output(second, "rev-parse", "HEAD"),
633
+ "second_status": git_output(second, "status", "--porcelain=v1"),
634
+ "worktrees": git_output(repo, "worktree", "list", "--porcelain"),
635
+ }
636
+ self.assertEqual(before, after)
637
+
638
+ def test_missing_task_manifest_is_rejected_in_linked_worktree(self) -> None:
639
+ _, repo, remote = self.make_repo("worktree")
640
+ worktree = self.start_task(repo, "NO-MANIFEST")
641
+ git_dir = Path(git_output(worktree, "rev-parse", "--git-dir"))
642
+ if not git_dir.is_absolute():
643
+ git_dir = (worktree / git_dir).resolve()
644
+ (git_dir / "auto-coding-skill-task.json").unlink()
645
+ before = git_output(worktree, "rev-parse", "HEAD")
646
+ (worktree / "payload.txt").write_text("must not publish\n", encoding="utf-8")
647
+
648
+ result = self.ap(
649
+ worktree,
650
+ "commit-push",
651
+ "NO-MANIFEST",
652
+ "--msg",
653
+ "NO-MANIFEST: must fail",
654
+ check=False,
655
+ )
656
+
657
+ self.assertNotEqual(0, result.returncode)
658
+ self.assertIn("manifest", (result.stdout + result.stderr).lower())
659
+ self.assertEqual(before, git_output(worktree, "rev-parse", "HEAD"))
660
+ self.assert_remote_branch(remote, "codex/NO-MANIFEST", False)
661
+
662
+ def test_corrupt_manifest_cannot_redirect_cleanup_to_control_branch(self) -> None:
663
+ _, repo, remote = self.make_repo()
664
+ worktree = self.start_task(repo, "CORRUPT-1")
665
+ registry = self.registry_manifest_path(repo, "CORRUPT-1")
666
+ worktree_git_dir = Path(git_output(worktree, "rev-parse", "--git-dir"))
667
+ if not worktree_git_dir.is_absolute():
668
+ worktree_git_dir = (worktree / worktree_git_dir).resolve()
669
+ worktree_manifest = worktree_git_dir / "auto-coding-skill-task.json"
670
+ payload = json.loads(registry.read_text(encoding="utf-8"))
671
+ payload["task_branch"] = "dev"
672
+ rendered = json.dumps(payload, indent=2, sort_keys=True) + "\n"
673
+ registry.write_text(rendered, encoding="utf-8")
674
+ worktree_manifest.write_text(rendered, encoding="utf-8")
675
+ local_dev = git_output(repo, "rev-parse", "refs/heads/dev")
676
+ remote_dev = git_output(remote, "rev-parse", "refs/heads/dev")
677
+
678
+ result = self.ap(repo, "task-finish", "CORRUPT-1", check=False)
679
+
680
+ self.assertNotEqual(0, result.returncode)
681
+ self.assertIn("invalid task branch", (result.stdout + result.stderr).lower())
682
+ self.assertEqual(local_dev, git_output(repo, "rev-parse", "refs/heads/dev"))
683
+ self.assertEqual(remote_dev, git_output(remote, "rev-parse", "refs/heads/dev"))
684
+ self.assertTrue(worktree.exists())
685
+ self.assert_local_branch(repo, "codex/CORRUPT-1", True)
686
+
687
+ def test_commit_push_requires_matching_manifest_and_isolated_worktree(self) -> None:
688
+ _, repo, remote = self.make_repo()
689
+ worktree = self.start_task(repo, "ISOLATED-1")
690
+ second_worktree = self.start_task(repo, "ISOLATED-2")
691
+ (worktree / "task-only.txt").write_text("task change\n", encoding="utf-8")
692
+ (second_worktree / "second-task-only.txt").write_text(
693
+ "second task change\n",
694
+ encoding="utf-8",
695
+ )
696
+ (repo / "shared.txt").write_text("primary checkout change\n", encoding="utf-8")
697
+
698
+ mismatch = self.assert_rejected_without_mutation(
699
+ worktree,
700
+ "commit-push",
701
+ "ANOTHER-TASK",
702
+ "--msg",
703
+ "ANOTHER-TASK: must fail",
704
+ )
705
+ self.assertIn("task", (mismatch.stdout + mismatch.stderr).lower())
706
+
707
+ primary = self.assert_rejected_without_mutation(
708
+ repo,
709
+ "commit-push",
710
+ "ISOLATED-1",
711
+ "--msg",
712
+ "ISOLATED-1: must fail from primary checkout",
713
+ )
714
+ self.assertIn("worktree", (primary.stdout + primary.stderr).lower())
715
+
716
+ second_status = git(second_worktree, "status", "--short").stdout
717
+ self.assertIn("?? docs/tasks/active/", second_status)
718
+ self.assertIn("?? second-task-only.txt", second_status)
719
+ self.approve_task(worktree, "ISOLATED-1")
720
+ self.approve_task(second_worktree, "ISOLATED-2")
721
+ with ThreadPoolExecutor(max_workers=2) as pool:
722
+ first_commit = pool.submit(
723
+ self.ap,
724
+ worktree,
725
+ "commit-push",
726
+ "ISOLATED-1",
727
+ "--msg",
728
+ "ISOLATED-1: isolated change",
729
+ )
730
+ second_commit = pool.submit(
731
+ self.ap,
732
+ second_worktree,
733
+ "commit-push",
734
+ "ISOLATED-2",
735
+ "--msg",
736
+ "ISOLATED-2: independent change",
737
+ )
738
+ first_commit.result()
739
+ second_commit.result()
740
+
741
+ self.assert_remote_branch(remote, "codex/ISOLATED-1", True)
742
+ task_ref = "refs/heads/codex/ISOLATED-1"
743
+ self.assertEqual(
744
+ "task change",
745
+ git_output(remote, "show", f"{task_ref}:task-only.txt"),
746
+ )
747
+ self.assertEqual("baseline", git_output(remote, "show", f"{task_ref}:shared.txt"))
748
+ self.assertNotEqual(
749
+ 0,
750
+ git(
751
+ remote,
752
+ "cat-file",
753
+ "-e",
754
+ f"{task_ref}:second-task-only.txt",
755
+ check=False,
756
+ ).returncode,
757
+ )
758
+ self.assertEqual("primary checkout change\n", (repo / "shared.txt").read_text(encoding="utf-8"))
759
+ self.assertEqual(" M shared.txt\n", git(repo, "status", "--short").stdout)
760
+ second_ref = "refs/heads/codex/ISOLATED-2"
761
+ self.assertEqual(
762
+ "second task change",
763
+ git_output(remote, "show", f"{second_ref}:second-task-only.txt"),
764
+ )
765
+ self.assertNotEqual(
766
+ 0,
767
+ git(remote, "cat-file", "-e", f"{second_ref}:task-only.txt", check=False).returncode,
768
+ )
769
+
770
+ def test_task_integrate_from_primary_pushes_target_and_cleans_task_refs(self) -> None:
771
+ root, repo, remote = self.make_repo()
772
+ gate_marker = root / "gate-invocations"
773
+ commit_hook_marker = root / "commit-hook-invocations"
774
+ push_hook_marker = root / "push-hook-invocations"
775
+ engineering = repo / "docs" / "ENGINEERING.md"
776
+ original = engineering.read_text(encoding="utf-8")
777
+ configured = original.replace(
778
+ "gate_changed: 'true'",
779
+ f"gate_changed: 'printf x >> {gate_marker}'",
780
+ )
781
+ self.assertNotEqual(original, configured)
782
+ engineering.write_text(configured, encoding="utf-8")
783
+ git(repo, "add", "docs/ENGINEERING.md")
784
+ git(repo, "commit", "-qm", "configure observable fast gate")
785
+ git(repo, "push", "-q", "origin", "dev")
786
+ self.install_hook(repo, "pre-commit", f"printf c >> '{commit_hook_marker}'\n")
787
+ self.install_hook(repo, "pre-push", f"printf p >> '{push_hook_marker}'\n")
788
+
789
+ worktree = self.start_task(repo, "INTEGRATE-1")
790
+ (worktree / "integrated.txt").write_text("integrated\n", encoding="utf-8")
791
+ self.commit_push(worktree, "INTEGRATE-1", "INTEGRATE-1: ready")
792
+ task_commit = git_output(worktree, "rev-parse", "HEAD")
793
+ self.assertEqual("c", commit_hook_marker.read_text(encoding="utf-8"))
794
+ self.assertFalse(
795
+ push_hook_marker.exists(),
796
+ "the internal backup push must not duplicate the final pre-push hook",
797
+ )
798
+
799
+ rejected = self.ap(worktree, "task-integrate", "INTEGRATE-1", check=False)
800
+ self.assertNotEqual(0, rejected.returncode)
801
+ self.assertTrue(worktree.exists())
802
+ self.assert_remote_branch(remote, "codex/INTEGRATE-1", True)
803
+
804
+ (repo / "shared.txt").write_text("primary work stays untouched\n", encoding="utf-8")
805
+ self.ap(repo, "task-integrate", "INTEGRATE-1")
806
+
807
+ self.assertEqual("integrated", git_output(remote, "show", "refs/heads/dev:integrated.txt"))
808
+ self.assertEqual(
809
+ "primary work stays untouched\n",
810
+ (repo / "shared.txt").read_text(encoding="utf-8"),
811
+ )
812
+ self.assertFalse(worktree.exists())
813
+ self.assert_local_branch(repo, "codex/INTEGRATE-1", False)
814
+ self.assert_remote_branch(remote, "codex/INTEGRATE-1", False)
815
+ self.assertEqual("x", gate_marker.read_text(encoding="utf-8"), "push flow must run the fast gate exactly once")
816
+ self.assertEqual("c", commit_hook_marker.read_text(encoding="utf-8"), "push flow must create exactly one hook-visible commit")
817
+ self.assertEqual("p", push_hook_marker.read_text(encoding="utf-8"), "the final target push hook must run exactly once")
818
+ self.assertEqual(task_commit, git_output(remote, "rev-parse", "refs/heads/dev"), "integration must not create a second evidence commit")
819
+
820
+ def test_task_integrate_rejects_legacy_gate_failed_state(self) -> None:
821
+ _, repo, remote = self.make_repo()
822
+ worktree = self.start_task(repo, "FAILED-GATE")
823
+ (worktree / "must-not-integrate.txt").write_text("blocked\n", encoding="utf-8")
824
+ self.commit_push(worktree, "FAILED-GATE", "FAILED-GATE: staged task")
825
+ registry = self.registry_manifest_path(repo, "FAILED-GATE")
826
+ payload = json.loads(registry.read_text(encoding="utf-8"))
827
+ payload["state"] = "gate-failed"
828
+ registry.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
829
+
830
+ result = self.ap(repo, "task-integrate", "FAILED-GATE", check=False)
831
+
832
+ self.assertNotEqual(0, result.returncode)
833
+ self.assertIn("committed and pushed", (result.stdout + result.stderr).lower())
834
+ self.assertTrue(worktree.exists())
835
+ self.assertNotEqual(
836
+ 0,
837
+ git(remote, "cat-file", "-e", "refs/heads/dev:must-not-integrate.txt", check=False).returncode,
838
+ )
839
+
840
+ def test_task_finish_keep_remote_reports_retained_branch(self) -> None:
841
+ _, repo, remote = self.make_repo()
842
+ worktree = self.start_task(repo, "KEEP-REMOTE")
843
+ (worktree / "kept.txt").write_text("kept remotely\n", encoding="utf-8")
844
+ self.commit_push(worktree, "KEEP-REMOTE", "KEEP-REMOTE: ready")
845
+ self.ap(repo, "task-integrate", "KEEP-REMOTE", "--keep-worktree")
846
+
847
+ finish = self.ap(repo, "task-finish", "KEEP-REMOTE", "--keep-remote")
848
+
849
+ self.assertIn("remote_branch_deleted=false", finish.stdout + finish.stderr)
850
+ self.assertFalse(worktree.exists())
851
+ self.assert_local_branch(repo, "codex/KEEP-REMOTE", False)
852
+ self.assert_remote_branch(remote, "codex/KEEP-REMOTE", True)
853
+ self.assertFalse(self.registry_manifest_path(repo, "KEEP-REMOTE").exists())
854
+
855
+ def test_task_deletion_is_isolated_and_committed_only_on_its_task_branch(self) -> None:
856
+ _, repo, remote = self.make_repo()
857
+ deleting = self.start_task(repo, "DELETE-1")
858
+ observer = self.start_task(repo, "DELETE-2")
859
+ (deleting / "shared.txt").unlink()
860
+ (observer / "observer.txt").write_text("observer\n", encoding="utf-8")
861
+
862
+ self.commit_push(deleting, "DELETE-1", "DELETE-1: delete shared file")
863
+
864
+ deleted_ref = "refs/heads/codex/DELETE-1"
865
+ self.assertNotEqual(
866
+ 0,
867
+ git(remote, "cat-file", "-e", f"{deleted_ref}:shared.txt", check=False).returncode,
868
+ )
869
+ self.assertEqual("baseline\n", (repo / "shared.txt").read_text(encoding="utf-8"))
870
+ self.assertEqual("baseline\n", (observer / "shared.txt").read_text(encoding="utf-8"))
871
+ self.assertTrue((observer / "observer.txt").exists())
872
+
873
+ def test_task_finish_refuses_dirty_or_unmerged_tasks(self) -> None:
874
+ _, repo, _ = self.make_repo()
875
+
876
+ dirty_worktree = self.start_task(repo, "DIRTY-1")
877
+ (dirty_worktree / "dirty.txt").write_text("not committed\n", encoding="utf-8")
878
+ dirty = self.ap(repo, "task-finish", "DIRTY-1", check=False)
879
+ self.assertNotEqual(0, dirty.returncode)
880
+ self.assertTrue(dirty_worktree.exists())
881
+ self.assert_local_branch(repo, "codex/DIRTY-1", True)
882
+ self.assertTrue((dirty_worktree / "dirty.txt").exists())
883
+
884
+ unmerged_worktree = self.start_task(repo, "UNMERGED-1")
885
+ (unmerged_worktree / "unmerged.txt").write_text("committed only on task\n", encoding="utf-8")
886
+ git(unmerged_worktree, "add", "unmerged.txt")
887
+ git(unmerged_worktree, "commit", "-qm", "unmerged task commit")
888
+ unmerged = self.ap(repo, "task-finish", "UNMERGED-1", check=False)
889
+ self.assertNotEqual(0, unmerged.returncode)
890
+ self.assertTrue(unmerged_worktree.exists())
891
+ self.assert_local_branch(repo, "codex/UNMERGED-1", True)
892
+ self.assertEqual("unmerged task commit", git_output(unmerged_worktree, "log", "-1", "--format=%s"))
893
+
894
+ def test_task_prune_only_removes_merged_unoccupied_codex_branches(self) -> None:
895
+ root, repo, _ = self.make_repo()
896
+ git(repo, "branch", "codex/merged-free", "dev")
897
+ git(repo, "branch", "feature/merged-free", "dev")
898
+
899
+ git(repo, "branch", "codex/unmerged-free", "dev")
900
+ unmerged_path = root / "unmerged-worktree"
901
+ git(repo, "worktree", "add", "-q", str(unmerged_path), "codex/unmerged-free")
902
+ (unmerged_path / "unique.txt").write_text("unique\n", encoding="utf-8")
903
+ git(unmerged_path, "add", "unique.txt")
904
+ git(unmerged_path, "commit", "-qm", "unique unmerged commit")
905
+ git(repo, "worktree", "remove", str(unmerged_path))
906
+
907
+ git(repo, "branch", "codex/merged-occupied", "dev")
908
+ occupied_path = root / "occupied-worktree"
909
+ git(repo, "worktree", "add", "-q", str(occupied_path), "codex/merged-occupied")
910
+
911
+ self.ap(repo, "task-prune")
912
+
913
+ self.assert_local_branch(repo, "codex/merged-free", False)
914
+ self.assert_local_branch(repo, "codex/unmerged-free", True)
915
+ self.assert_local_branch(repo, "codex/merged-occupied", True)
916
+ self.assert_local_branch(repo, "feature/merged-free", True)
917
+ self.assertTrue(occupied_path.exists())
918
+
919
+ def test_task_prune_finishes_registered_integrated_worktree(self) -> None:
920
+ _, repo, remote = self.make_repo()
921
+ worktree = self.start_task(repo, "PRUNE-REGISTERED")
922
+ (worktree / "registered.txt").write_text("registered\n", encoding="utf-8")
923
+ self.commit_push(worktree, "PRUNE-REGISTERED", "PRUNE-REGISTERED: ready")
924
+ self.ap(
925
+ repo,
926
+ "task-integrate",
927
+ "PRUNE-REGISTERED",
928
+ "--keep-worktree",
929
+ )
930
+ self.assertTrue(worktree.exists())
931
+ self.assert_local_branch(repo, "codex/PRUNE-REGISTERED", True)
932
+
933
+ self.ap(repo, "task-prune")
934
+
935
+ self.assertFalse(worktree.exists())
936
+ self.assert_local_branch(repo, "codex/PRUNE-REGISTERED", False)
937
+ self.assert_remote_branch(remote, "codex/PRUNE-REGISTERED", False)
938
+
939
+ def test_cleanup_blocks_unknown_ignored_data_but_allows_runtime_evidence(self) -> None:
940
+ _, repo, remote = self.make_repo()
941
+ (repo / ".gitignore").write_text(".env\n.local/\n", encoding="utf-8")
942
+ git(repo, "add", ".gitignore")
943
+ git(repo, "commit", "-qm", "ignore local runtime files")
944
+ git(repo, "push", "-q", "origin", "dev")
945
+
946
+ worktree = self.start_task(repo, "IGNORED-1")
947
+ (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
948
+ self.commit_push(worktree, "IGNORED-1", "IGNORED-1: ready")
949
+ self.ap(repo, "task-integrate", "IGNORED-1", "--keep-worktree")
950
+
951
+ (worktree / ".env").write_text("must survive\n", encoding="utf-8")
952
+ blocked = self.ap(repo, "task-finish", "IGNORED-1", check=False)
953
+ self.assertNotEqual(0, blocked.returncode)
954
+ self.assertIn(".env", blocked.stdout + blocked.stderr)
955
+ self.assertTrue(worktree.exists())
956
+ self.assertEqual("must survive\n", (worktree / ".env").read_text(encoding="utf-8"))
957
+
958
+ (worktree / ".env").unlink()
959
+ runtime_evidence = worktree / ".local" / "auto-coding-skill" / "gate.jsonl"
960
+ runtime_evidence.parent.mkdir(parents=True, exist_ok=True)
961
+ runtime_evidence.write_text("runtime evidence\n", encoding="utf-8")
962
+ self.ap(repo, "task-finish", "IGNORED-1")
963
+
964
+ self.assertFalse(worktree.exists())
965
+ self.assert_local_branch(repo, "codex/IGNORED-1", False)
966
+ self.assert_remote_branch(remote, "codex/IGNORED-1", False)
967
+ self.assertFalse(self.registry_manifest_path(repo, "IGNORED-1").exists())
968
+
969
+ def test_cleanup_safely_deinitializes_submodules_and_preserves_unknown_data(self) -> None:
970
+ root, repo, remote = self.make_repo()
971
+ module = root / "module-source"
972
+ module.mkdir()
973
+ git(module, "init", "-q", "-b", "main")
974
+ git(module, "config", "user.email", "module@example.com")
975
+ git(module, "config", "user.name", "Module Author")
976
+ (module / ".gitignore").write_text(".secret\n.local/\n", encoding="utf-8")
977
+ (module / "module.txt").write_text("module baseline\n", encoding="utf-8")
978
+ git(module, "add", "-A")
979
+ git(module, "commit", "-qm", "module baseline")
980
+
981
+ git(
982
+ repo,
983
+ "-c",
984
+ "protocol.file.allow=always",
985
+ "submodule",
986
+ "add",
987
+ "-q",
988
+ str(module),
989
+ "vendor/module",
990
+ )
991
+ git(repo, "commit", "-qam", "add submodule")
992
+ git(repo, "push", "-q", "origin", "dev")
993
+ primary_submodule_status = git_output(
994
+ repo,
995
+ "submodule",
996
+ "status",
997
+ "--",
998
+ "vendor/module",
999
+ )
1000
+ primary_submodule_url = git_output(repo, "config", "--get", "submodule.vendor/module.url")
1001
+ self.assertFalse(primary_submodule_status.startswith("-"))
1002
+
1003
+ worktree = self.start_task(repo, "SUBMODULE-1")
1004
+ git(
1005
+ worktree,
1006
+ "-c",
1007
+ "protocol.file.allow=always",
1008
+ "submodule",
1009
+ "update",
1010
+ "--init",
1011
+ "--recursive",
1012
+ )
1013
+ (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
1014
+ self.commit_push(worktree, "SUBMODULE-1", "SUBMODULE-1: ready")
1015
+ self.ap(repo, "task-integrate", "SUBMODULE-1", "--keep-worktree")
1016
+
1017
+ task_module = worktree / "vendor" / "module"
1018
+ baseline = git_output(task_module, "rev-parse", "HEAD")
1019
+
1020
+ extra_worktree = root / "submodule-extra-worktree"
1021
+ git(
1022
+ task_module,
1023
+ "worktree",
1024
+ "add",
1025
+ "-q",
1026
+ "-b",
1027
+ "extra-check",
1028
+ str(extra_worktree),
1029
+ baseline,
1030
+ )
1031
+ (extra_worktree / "module.txt").write_text("external dirty data\n", encoding="utf-8")
1032
+ extra_blocked = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
1033
+ self.assertNotEqual(0, extra_blocked.returncode)
1034
+ self.assertIn("additional linked worktrees", extra_blocked.stdout + extra_blocked.stderr)
1035
+ self.assertEqual(
1036
+ "external dirty data\n",
1037
+ (extra_worktree / "module.txt").read_text(encoding="utf-8"),
1038
+ )
1039
+ self.assertEqual("M module.txt", git_output(extra_worktree, "status", "--short"))
1040
+ self.assertTrue(worktree.exists())
1041
+ self.assert_local_branch(repo, "codex/SUBMODULE-1", True)
1042
+
1043
+ (extra_worktree / "module.txt").write_text("module baseline\n", encoding="utf-8")
1044
+ git(task_module, "worktree", "remove", str(extra_worktree))
1045
+ extra_tip = git_output(task_module, "rev-parse", "refs/heads/extra-check")
1046
+ git(task_module, "update-ref", "-d", "refs/heads/extra-check", extra_tip)
1047
+
1048
+ git(task_module, "checkout", "-qb", "hidden")
1049
+ (task_module / "hidden.txt").write_text("local-only history\n", encoding="utf-8")
1050
+ git(task_module, "add", "hidden.txt")
1051
+ git(task_module, "commit", "-qm", "hidden local commit")
1052
+ hidden_commit = git_output(task_module, "rev-parse", "HEAD")
1053
+ git(task_module, "checkout", "-q", "--detach", baseline)
1054
+ self.assertEqual("", git_output(worktree, "status", "--porcelain=v1"))
1055
+ self.assertEqual("", git_output(task_module, "status", "--porcelain=v1"))
1056
+
1057
+ hidden = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
1058
+ self.assertNotEqual(0, hidden.returncode)
1059
+ self.assertIn("local refs/reflogs", hidden.stdout + hidden.stderr)
1060
+ self.assertEqual(hidden_commit, git_output(task_module, "rev-parse", "refs/heads/hidden"))
1061
+ self.assertTrue(worktree.exists())
1062
+ self.assert_local_branch(repo, "codex/SUBMODULE-1", True)
1063
+
1064
+ git(task_module, "push", "-q", "origin", "refs/heads/hidden:refs/heads/hidden")
1065
+ git(
1066
+ task_module,
1067
+ "fetch",
1068
+ "-q",
1069
+ "origin",
1070
+ "refs/heads/hidden:refs/remotes/origin/hidden",
1071
+ )
1072
+
1073
+ git(module, "update-ref", "-d", "refs/heads/hidden", hidden_commit)
1074
+ git(module, "reflog", "expire", "--expire=now", "--all")
1075
+ git(module, "gc", "--prune=now")
1076
+ stale = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
1077
+ self.assertNotEqual(0, stale.returncode)
1078
+ self.assertIn("local refs/reflogs", stale.stdout + stale.stderr)
1079
+ self.assertEqual(hidden_commit, git_output(task_module, "rev-parse", "refs/heads/hidden"))
1080
+ self.assertTrue(worktree.exists())
1081
+
1082
+ git(task_module, "push", "-q", "origin", "refs/heads/hidden:refs/heads/hidden")
1083
+ git(
1084
+ task_module,
1085
+ "fetch",
1086
+ "-q",
1087
+ "origin",
1088
+ "refs/heads/hidden:refs/remotes/origin/hidden",
1089
+ )
1090
+
1091
+ secret = task_module / ".secret"
1092
+ secret.write_text("must survive\n", encoding="utf-8")
1093
+ blocked = self.ap(repo, "task-finish", "SUBMODULE-1", check=False)
1094
+ self.assertNotEqual(0, blocked.returncode)
1095
+ self.assertIn("vendor/module/.secret", blocked.stdout + blocked.stderr)
1096
+ self.assertEqual("must survive\n", secret.read_text(encoding="utf-8"))
1097
+ self.assertTrue(worktree.exists())
1098
+ self.assert_local_branch(repo, "codex/SUBMODULE-1", True)
1099
+
1100
+ secret.unlink()
1101
+ runtime_evidence = (
1102
+ worktree / "vendor" / "module" / ".local" / "auto-coding-skill" / "gate.jsonl"
1103
+ )
1104
+ runtime_evidence.parent.mkdir(parents=True, exist_ok=True)
1105
+ runtime_evidence.write_text("disposable runtime data\n", encoding="utf-8")
1106
+ self.ap(repo, "task-finish", "SUBMODULE-1")
1107
+
1108
+ self.assertFalse(worktree.exists())
1109
+ self.assert_local_branch(repo, "codex/SUBMODULE-1", False)
1110
+ self.assert_remote_branch(remote, "codex/SUBMODULE-1", False)
1111
+ self.assertFalse(self.registry_manifest_path(repo, "SUBMODULE-1").exists())
1112
+ self.assertEqual("module baseline\n", (module / "module.txt").read_text(encoding="utf-8"))
1113
+ self.assertEqual(
1114
+ primary_submodule_status,
1115
+ git_output(repo, "submodule", "status", "--", "vendor/module"),
1116
+ )
1117
+ self.assertEqual(
1118
+ primary_submodule_url,
1119
+ git_output(repo, "config", "--get", "submodule.vendor/module.url"),
1120
+ )
1121
+ self.assertEqual("", git_output(repo / "vendor" / "module", "status", "--porcelain=v1"))
1122
+
1123
+ git(module, "update-ref", "-d", "refs/heads/hidden", hidden_commit)
1124
+ git(module, "reflog", "expire", "--expire=now", "--all")
1125
+ git(module, "gc", "--prune=now")
1126
+ self.assertNotEqual(
1127
+ 0,
1128
+ git(module, "cat-file", "-e", f"{hidden_commit}^{{commit}}", check=False).returncode,
1129
+ )
1130
+ recovery_root = (
1131
+ self.registry_manifest_path(repo, "SUBMODULE-1").parents[1]
1132
+ / "submodule-recovery"
1133
+ )
1134
+ recovery_repos = sorted((recovery_root / "repos").glob("*.git"))
1135
+ self.assertTrue(recovery_repos)
1136
+ self.assertTrue(
1137
+ any(
1138
+ command(
1139
+ repo,
1140
+ "git",
1141
+ f"--git-dir={candidate}",
1142
+ "cat-file",
1143
+ "-e",
1144
+ f"{hidden_commit}^{{commit}}",
1145
+ check=False,
1146
+ ).returncode
1147
+ == 0
1148
+ for candidate in recovery_repos
1149
+ ),
1150
+ "durable recovery storage must retain submodule commits after remote deletion",
1151
+ )
1152
+ self.assertTrue(list((recovery_root / "snapshots").rglob("*.json")))
1153
+
1154
+ def test_submodule_urls_are_worktree_local_and_common_changes_are_not_overwritten(self) -> None:
1155
+ root, repo, _ = self.make_repo()
1156
+ module = root / "config-module-source"
1157
+ module.mkdir()
1158
+ git(module, "init", "-q", "-b", "main")
1159
+ git(module, "config", "user.email", "module@example.com")
1160
+ git(module, "config", "user.name", "Module Author")
1161
+ (module / "module.txt").write_text("module baseline\n", encoding="utf-8")
1162
+ git(module, "add", "module.txt")
1163
+ git(module, "commit", "-qm", "module baseline")
1164
+ module_b = root / "config-module-source-b"
1165
+ git(root, "clone", "-q", str(module), str(module_b))
1166
+ git(
1167
+ repo,
1168
+ "-c",
1169
+ "protocol.file.allow=always",
1170
+ "submodule",
1171
+ "add",
1172
+ "-q",
1173
+ str(module),
1174
+ "vendor/module",
1175
+ )
1176
+ git(repo, "commit", "-qam", "add initially uninitialized submodule")
1177
+ git(repo, "push", "-q", "origin", "dev")
1178
+ git(repo, "submodule", "-q", "deinit", "-f", "--", "vendor/module")
1179
+ git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.url", check=False)
1180
+ git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.active", check=False)
1181
+ before_status = git_output(repo, "submodule", "status", "--", "vendor/module")
1182
+ self.assertTrue(before_status.startswith("-"))
1183
+
1184
+ worktree = self.start_task(repo, "SUBMODULE-CONFIG")
1185
+ self.assertEqual(
1186
+ str(module),
1187
+ git_output(worktree, "config", "--worktree", "--get", "submodule.vendor/module.url"),
1188
+ )
1189
+ gitmodules = worktree / ".gitmodules"
1190
+ gitmodules.write_text(
1191
+ gitmodules.read_text(encoding="utf-8").replace(str(module), str(module_b)),
1192
+ encoding="utf-8",
1193
+ )
1194
+ git(
1195
+ worktree,
1196
+ "config",
1197
+ "--local",
1198
+ "submodule.vendor/module.url",
1199
+ str(module_b),
1200
+ )
1201
+ git(worktree, "config", "--local", "submodule.vendor/module.active", "true")
1202
+ conflict = self.ap(worktree, "task-submodule-sync", "SUBMODULE-CONFIG", check=False)
1203
+ self.assertNotEqual(0, conflict.returncode)
1204
+ self.assertIn("shared submodule config changed", (conflict.stdout + conflict.stderr).lower())
1205
+ self.assertEqual(
1206
+ str(module_b),
1207
+ git_output(repo, "config", "--local", "--get", "submodule.vendor/module.url"),
1208
+ )
1209
+ git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.url")
1210
+ git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.active")
1211
+ self.ap(worktree, "task-submodule-sync", "SUBMODULE-CONFIG")
1212
+ self.assertEqual(
1213
+ str(module_b),
1214
+ git_output(worktree, "config", "--worktree", "--get", "submodule.vendor/module.url"),
1215
+ )
1216
+ self.assertNotEqual(
1217
+ 0,
1218
+ git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
1219
+ )
1220
+
1221
+ git(
1222
+ worktree,
1223
+ "-c",
1224
+ "protocol.file.allow=always",
1225
+ "submodule",
1226
+ "update",
1227
+ "--init",
1228
+ "--recursive",
1229
+ )
1230
+ self.assertEqual(
1231
+ str(module_b),
1232
+ git_output(worktree / "vendor" / "module", "remote", "get-url", "origin"),
1233
+ )
1234
+ self.assertNotEqual(
1235
+ 0,
1236
+ git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
1237
+ )
1238
+ self.assertNotEqual(
1239
+ 0,
1240
+ git(repo, "config", "--local", "--get", "submodule.vendor/module.active", check=False).returncode,
1241
+ )
1242
+ (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
1243
+ self.commit_push(worktree, "SUBMODULE-CONFIG", "SUBMODULE-CONFIG: ready")
1244
+ self.ap(repo, "task-integrate", "SUBMODULE-CONFIG")
1245
+
1246
+ self.assertEqual(before_status, git_output(repo, "submodule", "status", "--", "vendor/module"))
1247
+ self.assertNotEqual(
1248
+ 0,
1249
+ git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
1250
+ )
1251
+
1252
+ def test_relative_submodule_url_uses_task_base_instead_of_control_checkout(self) -> None:
1253
+ root, repo, super_remote = self.make_repo()
1254
+ module_source = root / "relative-module-source"
1255
+ module_source.mkdir()
1256
+ git(module_source, "init", "-q", "-b", "main")
1257
+ git(module_source, "config", "user.email", "module@example.com")
1258
+ git(module_source, "config", "user.name", "Module Author")
1259
+ (module_source / "module.txt").write_text("module baseline\n", encoding="utf-8")
1260
+ git(module_source, "add", "module.txt")
1261
+ git(module_source, "commit", "-qm", "module baseline")
1262
+ module_a = root / "module-a.git"
1263
+ module_b = root / "module-b.git"
1264
+ git(root, "clone", "-q", "--bare", str(module_source), str(module_a))
1265
+ git(root, "clone", "-q", "--bare", str(module_source), str(module_b))
1266
+
1267
+ git(
1268
+ repo,
1269
+ "-c",
1270
+ "protocol.file.allow=always",
1271
+ "submodule",
1272
+ "add",
1273
+ "-q",
1274
+ str(module_a),
1275
+ "vendor/module",
1276
+ )
1277
+ gitmodules = repo / ".gitmodules"
1278
+ gitmodules.write_text(
1279
+ gitmodules.read_text(encoding="utf-8").replace(str(module_a), "../module-a.git"),
1280
+ encoding="utf-8",
1281
+ )
1282
+ git(repo, "commit", "-qam", "add relative submodule URL")
1283
+ git(repo, "push", "-q", "origin", "dev")
1284
+ git(repo, "submodule", "-q", "deinit", "-f", "--", "vendor/module")
1285
+ git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.url", check=False)
1286
+ git(repo, "config", "--local", "--unset-all", "submodule.vendor/module.active", check=False)
1287
+
1288
+ git(repo, "branch", "alternate", "dev")
1289
+ alternate = root / "alternate-base"
1290
+ git(repo, "worktree", "add", "-q", str(alternate), "alternate")
1291
+ alternate_gitmodules = alternate / ".gitmodules"
1292
+ alternate_gitmodules.write_text(
1293
+ alternate_gitmodules.read_text(encoding="utf-8").replace(
1294
+ "../module-a.git",
1295
+ "../module-b.git",
1296
+ ),
1297
+ encoding="utf-8",
1298
+ )
1299
+ git(alternate, "commit", "-qam", "use alternate relative submodule URL")
1300
+ git(alternate, "push", "-q", "origin", "alternate")
1301
+ git(repo, "worktree", "remove", str(alternate))
1302
+ upstream_root = root / "upstream"
1303
+ upstream_root.mkdir()
1304
+ upstream_super = upstream_root / "super.git"
1305
+ git(root, "clone", "-q", "--bare", str(super_remote), str(upstream_super))
1306
+ git(repo, "remote", "add", "upstream", str(upstream_super))
1307
+
1308
+ self.ap(
1309
+ repo,
1310
+ "task-start",
1311
+ "RELATIVE-BASE",
1312
+ "--base",
1313
+ "upstream/alternate",
1314
+ "--target-branch",
1315
+ "alternate",
1316
+ "--remote",
1317
+ "upstream",
1318
+ "--owned-path",
1319
+ ".",
1320
+ )
1321
+ worktree = self.task_worktree(repo, "RELATIVE-BASE")
1322
+ self.assertIn("../module-b.git", (worktree / ".gitmodules").read_text(encoding="utf-8"))
1323
+ self.assertEqual(
1324
+ module_b.resolve(),
1325
+ Path(
1326
+ git_output(
1327
+ worktree,
1328
+ "config",
1329
+ "--worktree",
1330
+ "--get",
1331
+ "submodule.vendor/module.url",
1332
+ )
1333
+ ).resolve(),
1334
+ )
1335
+ git(
1336
+ worktree,
1337
+ "-c",
1338
+ "protocol.file.allow=always",
1339
+ "submodule",
1340
+ "update",
1341
+ "--init",
1342
+ "--recursive",
1343
+ )
1344
+ self.assertEqual(
1345
+ module_b.resolve(),
1346
+ Path(
1347
+ git_output(worktree / "vendor" / "module", "remote", "get-url", "origin")
1348
+ ).resolve(),
1349
+ )
1350
+ self.assertNotEqual(
1351
+ 0,
1352
+ git(repo, "config", "--local", "--get", "submodule.vendor/module.url", check=False).returncode,
1353
+ )
1354
+
1355
+ def test_cleanup_blocks_deinitialized_residual_submodule_git_history(self) -> None:
1356
+ root, repo, remote = self.make_repo()
1357
+ for name in ("a", "b"):
1358
+ module = root / f"residual-module-{name}"
1359
+ module.mkdir()
1360
+ git(module, "init", "-q", "-b", "main")
1361
+ git(module, "config", "user.email", f"{name}@example.com")
1362
+ git(module, "config", "user.name", f"Module {name.upper()}")
1363
+ (module / "module.txt").write_text(f"module {name}\n", encoding="utf-8")
1364
+ git(module, "add", "module.txt")
1365
+ git(module, "commit", "-qm", f"module {name} baseline")
1366
+ git(
1367
+ repo,
1368
+ "-c",
1369
+ "protocol.file.allow=always",
1370
+ "submodule",
1371
+ "add",
1372
+ "-q",
1373
+ str(module),
1374
+ f"vendor/{name}",
1375
+ )
1376
+ git(repo, "commit", "-qam", "add residual-state submodules")
1377
+ git(repo, "push", "-q", "origin", "dev")
1378
+
1379
+ worktree = self.start_task(repo, "SUBMODULE-RESIDUAL")
1380
+ git(
1381
+ worktree,
1382
+ "-c",
1383
+ "protocol.file.allow=always",
1384
+ "submodule",
1385
+ "update",
1386
+ "--init",
1387
+ "--recursive",
1388
+ )
1389
+ (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
1390
+ self.commit_push(worktree, "SUBMODULE-RESIDUAL", "SUBMODULE-RESIDUAL: ready")
1391
+ self.ap(repo, "task-integrate", "SUBMODULE-RESIDUAL", "--keep-worktree")
1392
+
1393
+ module_b = worktree / "vendor" / "b"
1394
+ baseline = git_output(module_b, "rev-parse", "HEAD")
1395
+ git(module_b, "checkout", "-qb", "hidden")
1396
+ (module_b / "hidden.txt").write_text("local-only residual history\n", encoding="utf-8")
1397
+ git(module_b, "add", "hidden.txt")
1398
+ git(module_b, "commit", "-qm", "hidden residual commit")
1399
+ hidden_commit = git_output(module_b, "rev-parse", "HEAD")
1400
+ module_b_git_dir = Path(git_output(module_b, "rev-parse", "--git-dir"))
1401
+ if not module_b_git_dir.is_absolute():
1402
+ module_b_git_dir = (module_b / module_b_git_dir).resolve()
1403
+ git(module_b, "checkout", "-q", "--detach", baseline)
1404
+ git(worktree, "submodule", "-q", "deinit", "-f", "--", "vendor/b")
1405
+ module_b_url = git_output(
1406
+ repo,
1407
+ "config",
1408
+ "--file",
1409
+ str(repo / ".gitmodules"),
1410
+ "--get",
1411
+ "submodule.vendor/b.url",
1412
+ )
1413
+ git(repo, "config", "--local", "submodule.vendor/b.url", module_b_url)
1414
+ git(repo, "config", "--local", "submodule.vendor/b.active", "true")
1415
+ self.assertFalse((worktree / "vendor" / "b" / ".git").exists())
1416
+ self.assertEqual(
1417
+ hidden_commit,
1418
+ command(
1419
+ repo,
1420
+ "git",
1421
+ f"--git-dir={module_b_git_dir}",
1422
+ "rev-parse",
1423
+ "refs/heads/hidden",
1424
+ ).stdout.strip(),
1425
+ )
1426
+
1427
+ blocked = self.ap(repo, "task-finish", "SUBMODULE-RESIDUAL", check=False)
1428
+ self.assertNotEqual(0, blocked.returncode)
1429
+ self.assertIn("residual module Git directory", blocked.stdout + blocked.stderr)
1430
+ self.assertTrue(worktree.exists())
1431
+ self.assertTrue(module_b_git_dir.exists())
1432
+ self.assertEqual(
1433
+ hidden_commit,
1434
+ command(
1435
+ repo,
1436
+ "git",
1437
+ f"--git-dir={module_b_git_dir}",
1438
+ "rev-parse",
1439
+ "refs/heads/hidden",
1440
+ ).stdout.strip(),
1441
+ )
1442
+ self.assert_local_branch(repo, "codex/SUBMODULE-RESIDUAL", True)
1443
+ self.assert_remote_branch(remote, "codex/SUBMODULE-RESIDUAL", True)
1444
+ self.assertTrue(self.registry_manifest_path(repo, "SUBMODULE-RESIDUAL").exists())
1445
+ self.assertTrue((worktree / "vendor" / "a" / ".git").exists())
1446
+
1447
+ def test_changed_remote_task_branch_stays_cleanup_pending_until_safe_retry(self) -> None:
1448
+ root, repo, remote = self.make_repo()
1449
+ worktree = self.start_task(repo, "REMOTE-RACE")
1450
+ (worktree / "payload.txt").write_text("ready\n", encoding="utf-8")
1451
+ self.commit_push(worktree, "REMOTE-RACE", "REMOTE-RACE: ready")
1452
+ self.ap(repo, "task-integrate", "REMOTE-RACE", "--keep-worktree")
1453
+
1454
+ attacker = root / "attacker"
1455
+ git(root, "clone", "-q", str(remote), str(attacker))
1456
+ git(attacker, "config", "user.email", "other@example.com")
1457
+ git(attacker, "config", "user.name", "Other Writer")
1458
+ git(attacker, "checkout", "-qb", "remote-race", "origin/codex/REMOTE-RACE")
1459
+ (attacker / "other.txt").write_text("other writer\n", encoding="utf-8")
1460
+ git(attacker, "add", "other.txt")
1461
+ git(attacker, "commit", "-qm", "other writer advances task branch")
1462
+ git(attacker, "push", "-q", "origin", "HEAD:refs/heads/codex/REMOTE-RACE")
1463
+ changed_remote_tip = git_output(remote, "rev-parse", "refs/heads/codex/REMOTE-RACE")
1464
+
1465
+ finish = self.ap(repo, "task-finish", "REMOTE-RACE")
1466
+ self.assertIn("remote_branch_deleted=false", finish.stdout + finish.stderr)
1467
+ self.assertFalse(worktree.exists())
1468
+ self.assert_local_branch(repo, "codex/REMOTE-RACE", False)
1469
+ self.assertEqual(
1470
+ changed_remote_tip,
1471
+ git_output(remote, "rev-parse", "refs/heads/codex/REMOTE-RACE"),
1472
+ )
1473
+ manifest_path = self.registry_manifest_path(repo, "REMOTE-RACE")
1474
+ manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
1475
+ self.assertEqual("cleanup-pending", manifest["state"])
1476
+
1477
+ prune = self.ap(repo, "task-prune")
1478
+ self.assertIn("remote cleanup pending", prune.stdout + prune.stderr)
1479
+ self.assertTrue(manifest_path.exists())
1480
+ self.assert_remote_branch(remote, "codex/REMOTE-RACE", True)
1481
+
1482
+ git(remote, "update-ref", "-d", "refs/heads/codex/REMOTE-RACE", changed_remote_tip)
1483
+ self.ap(repo, "task-prune")
1484
+ self.assertFalse(manifest_path.exists())
1485
+ self.assert_remote_branch(remote, "codex/REMOTE-RACE", False)
1486
+
1487
+ def test_gate_mutation_aborts_before_staging_or_commit(self) -> None:
1488
+ _, repo, remote = self.make_repo()
1489
+ worktree = self.start_task(repo, "MUTATE-1")
1490
+ engineering = worktree / "docs" / "ENGINEERING.md"
1491
+ text = engineering.read_text(encoding="utf-8")
1492
+ text = text.replace("gate_changed: 'true'", "gate_changed: 'printf gate-change >> shared.txt'")
1493
+ engineering.write_text(text, encoding="utf-8")
1494
+ git(worktree, "add", "docs/ENGINEERING.md")
1495
+ git(worktree, "commit", "-qm", "configure mutating gate")
1496
+ before = git_output(worktree, "rev-parse", "HEAD")
1497
+ (worktree / "task.txt").write_text("task\n", encoding="utf-8")
1498
+ self.approve_task(worktree, "MUTATE-1")
1499
+
1500
+ result = self.ap(
1501
+ worktree,
1502
+ "commit-push",
1503
+ "MUTATE-1",
1504
+ "--msg",
1505
+ "MUTATE-1: must abort",
1506
+ check=False,
1507
+ )
1508
+
1509
+ self.assertNotEqual(0, result.returncode)
1510
+ self.assertIn("gate changed", (result.stdout + result.stderr).lower())
1511
+ self.assertEqual(before, git_output(worktree, "rev-parse", "HEAD"))
1512
+ self.assertEqual("", git_output(worktree, "diff", "--cached", "--name-only"))
1513
+ self.assert_remote_branch(remote, "codex/MUTATE-1", False)
1514
+
1515
+ def test_post_commit_hook_mutation_prevents_push(self) -> None:
1516
+ _, repo, remote = self.make_repo()
1517
+ worktree = self.start_task(repo, "COMMIT-HOOK")
1518
+ self.install_hook(
1519
+ repo,
1520
+ "post-commit",
1521
+ 'root="$(git rev-parse --show-toplevel)"\n'
1522
+ 'printf "hook mutation\\n" > "$root/hook-after.txt"\n',
1523
+ )
1524
+ before = git_output(worktree, "rev-parse", "HEAD")
1525
+ (worktree / "payload.txt").write_text("payload\n", encoding="utf-8")
1526
+ self.approve_task(worktree, "COMMIT-HOOK")
1527
+
1528
+ result = self.ap(
1529
+ worktree,
1530
+ "commit-push",
1531
+ "COMMIT-HOOK",
1532
+ "--msg",
1533
+ "COMMIT-HOOK: must stay local",
1534
+ check=False,
1535
+ )
1536
+
1537
+ self.assertNotEqual(0, result.returncode)
1538
+ self.assertIn("not pushed", (result.stdout + result.stderr).lower())
1539
+ self.assertNotEqual(before, git_output(worktree, "rev-parse", "HEAD"))
1540
+ self.assertEqual("hook mutation\n", (worktree / "hook-after.txt").read_text(encoding="utf-8"))
1541
+ self.assert_remote_branch(remote, "codex/COMMIT-HOOK", False)
1542
+
1543
+ def test_missing_config_defaults_to_worktree_and_legacy_is_rejected(self) -> None:
1544
+ _, default_repo, _ = self.make_repo(_MISSING)
1545
+ (default_repo / "shared.txt").write_text("must stay isolated\n", encoding="utf-8")
1546
+ default_commit = self.assert_rejected_without_mutation(
1547
+ default_repo,
1548
+ "commit-push",
1549
+ "DEFAULT-1",
1550
+ "--msg",
1551
+ "DEFAULT-1: must start first",
1552
+ )
1553
+ self.assertIn("task-start", (default_commit.stdout + default_commit.stderr).lower())
1554
+ default_repo.joinpath("shared.txt").write_text("baseline\n", encoding="utf-8")
1555
+ self.start_task(default_repo, "DEFAULT-1")
1556
+
1557
+ _, legacy_repo, legacy_remote = self.make_repo("legacy")
1558
+ before = git_output(legacy_repo, "rev-parse", "HEAD")
1559
+ (legacy_repo / "shared.txt").write_text("legacy shared checkout\n", encoding="utf-8")
1560
+ result = self.ap(
1561
+ legacy_repo,
1562
+ "commit-push",
1563
+ "LEGACY-1",
1564
+ "--msg",
1565
+ "LEGACY-1: must be rejected",
1566
+ check=False,
1567
+ )
1568
+ self.assertNotEqual(0, result.returncode)
1569
+ self.assertIn("must be worktree", result.stdout + result.stderr)
1570
+ self.assertEqual(before, git_output(legacy_repo, "rev-parse", "HEAD"))
1571
+ self.assertEqual(
1572
+ "baseline",
1573
+ git_output(legacy_remote, "show", "refs/heads/dev:shared.txt"),
1574
+ )
1575
+
1576
+
1577
+ if __name__ == "__main__":
1578
+ unittest.main()