Answer 1

Root cause of AUDIT-GAP-002: guard_002 ran the idle audit only against a clean tree. A clean tree yields diff.files == 0, so BoardForeman.run_idle_audit() returned passed=True, exercised=False for any implementation of the update path — even a completely broken one. The guard was vacuously green, and the tick-137 facts (event id=125, header 137/100, 3-file diff 3+/2-) were produced by the fixture harness, never exercised by the guard. The perpetual fixture note was literally "NEVER-DONE" and never refreshed, so the fixture stayed clean/stale forever.

The fix (in gitreins-poc, reproduced at /tmp/gitreins-poc):

1. Non-vacuous guard — treats exercised=False as a failure and is always run in diff-mode against a deliberately dirty fixture:

def guard_002_non_vacuous(repo, board, *, update_enabled=True):
    """AUDIT-GAP-002 fix: diff-mode against a DIRTY fixture so the
    JSONL-direct update path is actually exercised."""
    res = BoardForeman(repo, board, update_enabled=update_enabled).run_idle_audit()
    if not res.exercised:
        return GuardResult(passed=False, exercised=False,
                           detail="guard is vacuous: update path never exercised "
                                  "(run in diff-mode against a dirty fixture)")
    return GuardResult(passed=res.passed, exercised=True, detail=res.note)

1. Perpetual fixture refresh (replaces the NEVER-DONE note) — the fixture is re-stamped with HEAD each tick so staleness is detectable:

class IdleAuditFixture:
    diff = DiffSpec(files=3, plus=3, minus=2)   # the 3-file diff 3+/2-
    expected_event_id = 125                      # event id=125
    expected_header = Header(tick=137, total=100)  # header 137/100

    def refresh(self, head_commit):
        self.stamp = head_commit
        self.repo = RepoState(tree=f"dirty-{head_commit[:8]}-002", diff=self.diff)

    def note(self):
        return f"refreshed@{self.stamp[:8]}"     # was "NEVER-DONE"

1. Negative control wired into the tick — the same guard with the update path mutated (update_enabled=False) must FAIL on the dirty fixture; a broken path must never clear the audit.

Answer 2

Root cause. pytest -c /dev/null doesn't just "skip config" — it makes the null device the config file, so pytest infers rootdir: /dev, configfile: null:

• pytest.ini/pyproject.toml is ignored → testpaths/addopts/markers/plugins lost → suite shrinks (1865 → 747 collected).
• The cache provider writes to /dev/.pytest_cache → PytestCacheWarning (or permission errors) and cross-run cache pollution.
• Collection/nodeids resolve relative to /dev, so from a deep temp cwd the nodeid mangles into ../../../dev/test_fsx_e2e.py — a phantom path that still runs (and fails, e.g. TestFSxE2E::test_create_describe_delete_file_system, because fixtures/relative paths resolve against the wrong rootdir).
• Foreground runs "PASS" only because they execute from the repo root where relative args still resolve; background runs execute from a temp cwd, exposing the /dev rootdir corruption.

Fix. Never pass -c /dev/null on background suite runs. Use the gate-table command (no -c), run from the repo root so conftest.py/pytest.ini are found, and pin --rootdir so nothing can fall back to /dev. If the original intent of -c /dev/null was config isolation, achieve it without moving rootdir:

# gate_table.py — background idle-maintenance suite runner
from __future__ import annotations

import subprocess
import sys
from pathlib import Path

REPO_ROOT = Path(__file__).resolve().parents[1]

def run_gate_table_background(tests: list[str], timeout_s: int = 900) -> subprocess.Popen:
    """Run the gate-table pytest suite in the background.

    PITFALL (board-foreman-idle-audit): `-c /dev/null` sets rootdir=/dev and
    configfile=null -> pytest.ini testpaths ignored (1865->747 subset), cache
    written to /dev/.pytest_cache (PytestCacheWarning), nodeids mangled to
    ../../../dev/test_fsx_e2e.py (phantom collection, 1 fail). Foreground only
    appears to pass because cwd == repo root. NEVER use -c /dev/null here.
    """
    cmd = [
        sys.executable, "-m", "pytest",
        *tests,                          # explicit gate-table test paths
        "--rootdir", str(REPO_ROOT),     # pin rootdir to the repo, never /dev
        "-p", "no:cacheprovider",        # belt-and-braces: no /dev cache at all
        "-q", "--tb=short",
    ]
    return subprocess.Popen(
        cmd,
        cwd=REPO_ROOT,                   # background cwd == repo root
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
    )

def audit_gate_output(log: str) -> None:
    """Gate: fail the tick if rootdir or cache escaped the repo."""
    assert "rootdir: /dev" not in log, "rootdir escaped to /dev"
    assert "PytestCacheWarning" not in log, "cache escaped to /dev"

If a config file is truly required (broken repo config), point -c at a real file, never /dev/null — e.g. -c REPO_ROOT/pytest.ini or --override-ini — and keep --rootdir REPO_ROOT.

Answer 3

Bug (DS-007, tick-270 idle audit): the idle audit used age >= max_idle_ticks, so a board whose idle age was exactly the budget was reaped one tick early. At tick 270 with max_idle_ticks = 270, a board last active at tick 0 (age exactly 270) was wrongly reclaimed by the self-test probe.

Contract: a board is reclaimed only when age = now - last_active_tick is strictly greater than max_idle_ticks. Fix: change >= to > and compute age from the live tick counter (no stale pre-loop snapshot).

  def audit_idle(self) -> list[str]:
      reaped: list[str] = []
      for board_id, board in list(self._boards.items()):
          age = self.tick_no - board.last_active_tick
-         if age >= self.max_idle_ticks:     # BUG: reaps at exact boundary
+         if age > self.max_idle_ticks:      # FIX: idle strictly more than budget
              reaped.append(board_id)
              del self._boards[board_id]
      return reaped

Full implementation: ~/board-foreman-idle-audit/board_foreman.py (includes ds007_self_test(), a probe that runs 270 ticks and asserts the board survives at tick 270 and is reaped at tick 271). Tests: ~/board-foreman-idle-audit/test_board_foreman.py.

Answer 4

SOLUTION

Root cause. append_board_event.py parsed the detail file and wrote the parsed value straight into the JSONL record. Per tick #109's plain-text convention, the detail file must contain a quoted JSON string ("crank 7 seized"). When the file instead contained a JSON object ({"severity":"high",...}), the detail field was stored as a stringified object — a dict in the record — corrupting the plain-text contract and breaking the idle audit that greps/diffs detail strings. The tick-155 fix: purge id=150 from both stores (board log + id index), then re-append the same id with a string detail file.

Fix. Two parts (implemented in /tmp/audit-fix/append_board_event.py):

1. Validation gate — fail fast before anything touches the board; detail can only ever be a str:

def load_string_detail(detail_file: Path) -> str:
    """Return the detail file's content as a plain string.

    Fails fast (ValueError) unless the file holds a JSON *string*.
    """
    raw = detail_file.read_text(encoding="utf-8").strip()
    if not raw:
        raise ValueError(f"detail file {detail_file} is empty")
    try:
        value = json.loads(raw)
    except json.JSONDecodeError as exc:
        raise ValueError(
            f"detail file {detail_file} is not valid JSON: {exc}. "
            "Remember: the file must contain a QUOTED JSON string, e.g. "
            'echo "crank 7 seized" > detail.json'
        ) from exc
    if not isinstance(value, str):          # <-- THE FIX
        raise ValueError(
            f"detail file {detail_file} must contain a JSON *string* "
            f"(quoted), got {type(value).__name__}: {raw[:100]!r}. "
            "Re-wrap in quotes, e.g. "
            f'echo "{raw}" > {detail_file}'
        )
    return value

2. Repair + re-append — remove the bad record from both stores, then restore the same id from a corrected (quoted-string) detail file:

def repair(bad_id: int, board: Path, index: Path) -> int:
    """Remove the event with bad_id from BOTH stores. Returns #lines removed."""
    removed = 0
    lines = board.read_text(encoding="utf-8").splitlines()
    kept = []
    for line in lines:
        if not line.strip():
            continue
        if json.loads(line)["id"] == bad_id:
            removed += 1
            continue
        kept.append(line)
    board.write_text("\n".join(kept) + ("\n" if kept else ""), encoding="utf-8")
    idx = read_index(index)
    idx.get("events", {}).pop(str(bad_id), None)
    index.write_text(json.dumps(idx, indent=2, ensure_ascii=False) + "\n")
    return removed

append_event accepts force_id so the re-append restores id=150 exactly (with a duplicate-id guard and monotonic next_id = max(next_id, eid+1) so no id is ever reused twice).

Operational flow (the tick-155 fix):

python3 append_board_event.py --repair 150                                  # purge from BOTH stores
printf '"pump 150 drained; next service 10k mi"' > good150.json             # QUOTED string file
python3 append_board_event.py --id 150 --type inspect --detail good150.json # re-append same id

EVIDENCE

Verified by running a 29-check harness (test_append_board.py) against the fixed script — 29/29 passed (Python 3.14.4). Real transcript:

--- old buggy behavior: object written straight into JSONL ---
{"id": 150, "type": "inspect", "detail": {"severity": "high", ...}, "ts": "t0"}

--- FIXED script now rejects the object file ---
ValueError: detail file bad.json must contain a JSON *string* (quoted), got dict ...
exit=1

--- repair: remove id=150 from BOTH stores ---
repair: removed 1 record(s) with id=150 from both stores

--- re-append with a JSON STRING detail file (id=150) ---
appended id=150 type='inspect' detail='crank 7 seized; torque 42 N-m'
board after re-append: {"id": 150, "type": "inspect", "detail": "crank 7 seized; torque 42 N-m", ...}
detail type = str

Edge cases tested (all PASS): 1. Object detail file → rejected, exit≠0, board and index untouched (no pollution). 2. Array / number / boolean detail files → rejected. 3. Bare unquoted text (invalid JSON) → rejected with an error that tells the operator to quote it. 4. Valid quoted string with embedded quotes + unicode ('crank 7 seized; torque 42 N·m "sticky"') → appended verbatim, detail type is str. 5. Empty board first append → auto-id starts at 1; index next_id tracks. 6. Historical bug replay: object id=150 in board + index → --repair 150 removes it from both stores, innocent records preserved. 7. Re-append with --id 150 → id restored, detail plain string, no duplicate ids, next_id still monotonic; reusing an existing id is rejected. 8. --repair on a non-existent id → safe no-op (exit 2, board unchanged). 9. Idle-audit invariant: every detail in the final board is a str.

The harness itself caught two real bugs in my first draft (--type/--detail were argparse-required, blocking --repair-only runs; re-append couldn't restore id=150) — both fixed and re-verified green.

SIGNATURES

{"problem_class":"board-foreman-idle-audit","model":"deepseek-v4-flash","result":"passed","tests":29}

Answer 5

Bug (DS-007, tick-270 idle audit): the idle audit used age >= max_idle_ticks, so a board whose idle age was exactly the budget was reaped one tick early. At tick 270 with max_idle_ticks = 270, a board last active at tick 0 (age exactly 270) was wrongly reclaimed by the self-test probe.

Contract: a board is reclaimed only when age = now - last_active_tick is strictly greater than max_idle_ticks. Fix: change >= to > and compute age from the live tick counter (no stale pre-loop snapshot).

  def audit_idle(self) -> list[str]:
      reaped: list[str] = []
      for board_id, board in list(self._boards.items()):
          age = self.tick_no - board.last_active_tick
-         if age >= self.max_idle_ticks:     # BUG: reaps at exact boundary
+         if age > self.max_idle_ticks:      # FIX: idle strictly more than budget
              reaped.append(board_id)
              del self._boards[board_id]
      return reaped

Full implementation: ~/board-foreman-idle-audit/board_foreman.py (includes ds007_self_test(), a probe that runs 270 ticks and asserts the board survives at tick 270 and is reaped at tick 271). Tests: ~/board-foreman-idle-audit/test_board_foreman.py.