A small worktree repro: shared SQLite can hide a missing test fixture

[ryanroundhouse]

If you run Codex in several worktrees, a clean checkout can still be testing against another task's data. Here is a small, Python standard-library reproduction you can inspect and run without a coding agent or a database server.

The setup deliberately leaves out B's fixture-seeding step. A and B are separate Git worktrees at the same commit, running the same Python file and deliberately configured to use the same database path. The check asks whether an expected row exists; it does not establish which task created that row.

Observed sequence

On Linux with Python 3.12.14, SQLite 3.53.1 and Git 2.52.0:

1. B checks an empty shared database: fails.
2. A seeds that shared database.
3. B runs the unchanged check against it: passes, despite never running its own setup.
4. B checks a separate empty database: fails again.
5. B seeds its own database, then repeats the check: passes.

Both Git worktrees remain clean. The code and check stay unchanged throughout. The changing database contents explain the result. This is a deliberately weak fixture-presence check that exposes a missing setup step, not evidence that the application's behavior is correct.

Reproduce it

Requires Python 3.9+ with sqlite3 and Git on PATH. Only the versions above were tested. Save this as repro.py outside any repository, review it, then run python3 repro.py. It creates a new temporary repository, two linked worktrees and synthetic SQLite files, verifies all six subprocess outcomes, and removes only its generated temporary folder after normal execution or handled exceptions. Abrupt termination can leave that temporary folder behind. It does not install packages, contact the network, use credentials, run agents or change an existing repository. Git and Python themselves must be trusted.

Complete standalone reproduction

#!/usr/bin/env python3
"""Synthetic Git/SQLite shared-fixture demonstration. No agent or network calls.
Requires Python 3.9+ with sqlite3, and Git. Writes only inside a new temporary
folder and removes that generated folder at exit. Review before running.
"""
from pathlib import Path
from tempfile import TemporaryDirectory
import os
import platform
import sqlite3
import subprocess
import sys

WORKER = '''import sqlite3, sys
with sqlite3.connect(sys.argv[1]) as db:
    db.execute("CREATE TABLE IF NOT EXISTS items (name TEXT PRIMARY KEY)")
    if sys.argv[2] == "seed":
        db.execute("INSERT INTO items VALUES ('expected-item')")
    else:
        count = db.execute("SELECT count(*) FROM items WHERE name='expected-item'").fetchone()[0]
        print("PASS" if count == 1 else "FAIL: expected fixture absent")
        raise SystemExit(0 if count == 1 else 1)
'''


def main():
    # Ignore inherited Git repository/config selectors for this disposable demo.
    env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
    env["GIT_CONFIG_NOSYSTEM"] = "1"
    env["GIT_CONFIG_GLOBAL"] = os.devnull
    env["PYTHONDONTWRITEBYTECODE"] = "1"
    with TemporaryDirectory(prefix="worktree-db-repro-") as folder:
        root = Path(folder)
        main_repo, a, b = (root / n for n in ("main", "a", "b"))
        empty = root / "empty"
        empty.mkdir()

        def git(where, *args):
            return subprocess.run(
                ["git", "-c", f"core.hooksPath={empty}", "-c", "commit.gpgsign=false",
                 "-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid",
                 "-C", str(where), *args], env=env, text=True,
                capture_output=True, check=True).stdout.strip()

        git(root, "init", "--quiet", f"--template={empty}", str(main_repo))
        (main_repo / "worker.py").write_text(WORKER, encoding="utf-8")
        git(main_repo, "add", "--force", "worker.py")
        git(main_repo, "commit", "--quiet", "-m", "Synthetic fixture")
        git(main_repo, "worktree", "add", "--quiet", "-b", "fixture-a", str(a))
        git(main_repo, "worktree", "add", "--quiet", "-b", "fixture-b", str(b))
        shared, own_b = root / "shared.sqlite", root / "b-only.sqlite"

        def worker(where, database, action):
            return subprocess.run([sys.executable, "-I", "-B", "worker.py",
                                   str(database), action], cwd=where, env=env,
                                  text=True, capture_output=True)

        def expect(label, where, database, action, code, output):
            result = worker(where, database, action)
            if (result.returncode, result.stdout.strip(), result.stderr) != (code, output, ""):
                raise RuntimeError(f"{label}: unexpected result {result!r}")
            print(f"{label}: exit={code}" + (f"; {output}" if output else ""))

        print(f"Python {platform.python_version()}; SQLite {sqlite3.sqlite_version}; {git(root, '--version')}")
        expect("B / shared DB / before A seed", b, shared, "check", 1, "FAIL: expected fixture absent")
        expect("A / shared DB / seed", a, shared, "seed", 0, "")
        expect("B / shared DB / after A seed", b, shared, "check", 0, "PASS")
        expect("B / separate DB / before B seed", b, own_b, "check", 1, "FAIL: expected fixture absent")
        expect("B / separate DB / seed", b, own_b, "seed", 0, "")
        expect("B / separate DB / after B seed", b, own_b, "check", 0, "PASS")
        for name, checkout in (("A", a), ("B", b)):
            if git(checkout, "status", "--porcelain", "--untracked-files=all"):
                raise RuntimeError(f"{name}: unexpected checkout changes")
        print("A and B Git status: clean; same committed worker code throughout")
        print("All six expected process results verified. This is not a Codex or Zozo run.")


if __name__ == "__main__":
    main()

What to put in a review handoff

Alongside the tested commit and actual test command, record which database or fixture namespace the test used, who initialized it, and whether the test still passes from its own fresh fixture. Keep connection strings, credentials and private paths out of public reports. If multiple tasks intentionally share mutable state, serialize them or use an explicitly reviewed isolation scheme. Do not reset a shared database or kill another task's process just to get a green run.

This sequence is deterministic, not concurrent. It does not test locking, port allocation, Postgres, a Codex session or a Zozo Run. A separate SQLite file prevents this demonstrated contamination; it does not isolate every service, credential or host resource. Git's worktree documentation describes multiple working trees and shared repository resources, not separate application databases.

Disclosure: I'm Ryan, founder of Zozo HQ. This example and post were prepared with AI assistance. Our Local guide explicitly says agents run as the local user; I am not claiming Zozo automatically isolates external databases. This is a standalone environment check for anyone reviewing worktree-based coding work.

Which shared resource most often makes your local test result hard to reproduce: fixture data, a server port, a cache, or something else?