bigpowers 2.90.0 → 2.90.2

package/.gemini/extensions/bigpowers/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.90.0",
+  "version": "2.90.2",
   "description": "80 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "gemini-extension"

package/.pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.90.0",
+  "version": "2.90.2",
   "description": "80 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "pi-package"

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.90.2](https://github.com/danielvm-git/bigpowers/compare/v2.90.1...v2.90.2) (2026-11-03)
+
+
+### Bug Fixes
+
+* **scripts:** write spec state atomically instead of in place ([#192](https://github.com/danielvm-git/bigpowers/issues/192)) ([6198138](https://github.com/danielvm-git/bigpowers/commit/61981388c6ab80e493ae7582749730b41c89fa24)), closes [#181](https://github.com/danielvm-git/bigpowers/issues/181)
+
+## [2.90.1](https://github.com/danielvm-git/bigpowers/compare/v2.90.0...v2.90.1) (2026-11-03)
+
+
+### Bug Fixes
+
+* **omp:** keep the tool_call branch probe quiet outside a git repo ([#190](https://github.com/danielvm-git/bigpowers/issues/190)) ([bcacf33](https://github.com/danielvm-git/bigpowers/commit/bcacf33ec72a8705c6b0dbbcf91f2ea2bed4b406)), closes [#189](https://github.com/danielvm-git/bigpowers/issues/189)
+
 # [2.90.0](https://github.com/danielvm-git/bigpowers/compare/v2.89.1...v2.90.0) (2026-11-03)
 
 

package/extensions/omp-hooks.ts

@@ -205,11 +205,19 @@ function inGitRepo(cwd?: string): boolean {
 }
 
 function currentBranch(cwd: string): string {
+  // Probing a directory that is not a repository makes git print
+  // "fatal: not a git repository (or any of the parent directories): .git".
+  // execSync inherits fd 2 when no stdio option is given, so that message is
+  // painted straight over the TUI input line and vanishes on the next redraw
+  // (BUG-2026-11-03-omp-hooks-stderr-leak, issue #189). Ask inGitRepo() first —
+  // it is silent — so a non-repo target spawns no git process at all.
+  if (!inGitRepo(cwd)) return "unknown";
   try {
     return execSync("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       timeout: 3000,
       cwd,
+      stdio: ["ignore", "pipe", "ignore"],
     }).trim();
   } catch {
     return "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.90.0",
+  "version": "2.90.2",
   "description": "73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "main": "index.js",
   "scripts": {

package/scripts/lib/ab_report.py

@@ -7,11 +7,15 @@ from __future__ import annotations
 import json
 import random
 import subprocess
+import sys
 from datetime import date
 from pathlib import Path
 
 import yaml
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from atomic_write import atomic_write_text  # noqa: E402
+
 REPO_ROOT = Path(__file__).resolve().parents[2]
 BOOTSTRAP_RESAMPLES = 1000
 BOOTSTRAP_SEED = 58
@@ -96,10 +100,13 @@ def write_reports(out: Path, meta: dict, result: dict, records: list[dict]) -> P
     out.mkdir(parents=True, exist_ok=True)
     today = date.today().isoformat()
     report = out / f"AB-{today}.yaml"
-    report.write_text(yaml.safe_dump({**meta, **result}, sort_keys=False))
-    with (out / f"ab-runs-{today}.jsonl").open("w") as f:
-        for rec in records:
-            f.write(json.dumps({**rec, "bigpowers_sha": meta["bigpowers_sha"]}) + "\n")
+    # Atomic (#181): the dashboard reads these while a run is still appending.
+    atomic_write_text(report, yaml.safe_dump({**meta, **result}, sort_keys=False))
+    records_path = out / f"ab-runs-{today}.jsonl"
+    atomic_write_text(
+        records_path,
+        "".join(json.dumps({**rec, "bigpowers_sha": meta["bigpowers_sha"]}) + "\n" for rec in records),
+    )
     return report
 
 

package/scripts/lib/atomic_write.py

@@ -0,0 +1,71 @@
+"""Atomic file replacement for spec state (BUG-2026-11-03-atomic-yaml-writes, #181).
+
+`Path.write_text()` truncates the destination first and then streams the new
+bytes into it. Any concurrent reader — the dashboard snapshot loop, a subagent,
+a background gate — can observe the file after the truncate and before the last
+chunk lands, and fails with `yaml.scanner.ScannerError` on a file that a moment
+later is perfectly valid. Interrupting the agent mid-write leaves the file
+truncated for good.
+
+`atomic_write_text()` never exposes a partial file: the bytes go to a temporary
+file in the same directory, are flushed and fsynced, and only then replace the
+destination with `os.replace()` (a single atomic rename on POSIX). Readers see
+the old content or the new content, never a mix.
+
+Same-directory temp file is required: `os.replace` is atomic only within one
+filesystem, and `tempfile.mkstemp(dir=...)` guarantees that.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+import tempfile
+from pathlib import Path
+
+
+def atomic_write_bytes(path: str | Path, data: bytes, mode: int | None = None) -> None:
+    """Replace `path` with `data` atomically. Preserves the target's mode."""
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    if mode is None and target.exists():
+        mode = stat.S_IMODE(target.stat().st_mode)
+
+    fd, tmp_name = tempfile.mkstemp(dir=str(target.parent), prefix=f".{target.name}.", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        if mode is not None:
+            os.chmod(tmp_name, mode)
+        os.replace(tmp_name, target)
+    except BaseException:
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        raise
+
+    _fsync_dir(target.parent)
+
+
+def atomic_write_text(path: str | Path, text: str, encoding: str = "utf-8", mode: int | None = None) -> None:
+    """Atomic replacement for `Path.write_text()`."""
+    atomic_write_bytes(path, text.encode(encoding), mode=mode)
+
+
+def _fsync_dir(directory: Path) -> None:
+    """Persist the rename itself. Best-effort: not every platform allows it."""
+    flags = getattr(os, "O_DIRECTORY", 0)
+    try:
+        dir_fd = os.open(str(directory), os.O_RDONLY | flags)
+    except OSError:
+        return
+    try:
+        os.fsync(dir_fd)
+    except OSError:
+        pass
+    finally:
+        os.close(dir_fd)

package/scripts/lib/blind-spot-checks.py

@@ -6,6 +6,8 @@
 import json, os, re, sys
 from pathlib import Path
 from datetime import datetime, timezone
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from atomic_write import atomic_write_text  # noqa: E402
 
 ROOT = Path(sys.argv[1])
 BLIND_SPOTS_JSON = Path(sys.argv[2])
@@ -202,7 +204,7 @@ blind_spots = {
 }
 
 BLIND_SPOTS_JSON.parent.mkdir(parents=True, exist_ok=True)
-BLIND_SPOTS_JSON.write_text(json.dumps(blind_spots, indent=2), encoding="utf-8")
+atomic_write_text(BLIND_SPOTS_JSON, json.dumps(blind_spots, indent=2), encoding="utf-8")
 
 print(f"check-blind-spots.sh: {len(findings)} findings ({high_count} HIGH, {medium_count} MEDIUM, {low_count} LOW)")
 for f in findings:

package/scripts/lib/blind-spots.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 import json, os, re, sys
 from pathlib import Path
 from datetime import datetime, timezone
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from atomic_write import atomic_write_text  # noqa: E402
 
 ROOT = Path(sys.argv[1])
 BLIND_SPOTS_JSON = Path(sys.argv[2])
@@ -260,7 +262,7 @@ blind_spots = {
 }
 
 BLIND_SPOTS_JSON.parent.mkdir(parents=True, exist_ok=True)
-BLIND_SPOTS_JSON.write_text(json.dumps(blind_spots, indent=2), encoding="utf-8")
+atomic_write_text(BLIND_SPOTS_JSON, json.dumps(blind_spots, indent=2), encoding="utf-8")
 
 print(f"check-blind-spots.sh: {len(findings)} findings ({high_count} HIGH, {medium_count} MEDIUM, {low_count} LOW)")
 for f in findings:

package/scripts/lib/golden-suite-gates.sh

@@ -81,6 +81,8 @@ GOLDEN_GATES=(
   "golden-gate-runner:bash scripts/test-golden-gate-runner.sh:false"
   # Pipefail SIGPIPE races: fix shapes hold, git output never feeds grep -q/head.
   "pipefail-pipe-race:bash scripts/test-pipefail-pipe-race.sh:false"
+  # Atomic state writes: no reader ever sees a truncated YAML/JSON file (#181).
+  "atomic-writes:bash scripts/test-atomic-writes.sh:false"
   # One pipeline, release needs: every gate, pinned runner and actions.
   "ci-pipeline-contract-selftest:bash scripts/test-ci-pipeline-contract.sh --self-test:false"
   "ci-pipeline-contract:bash scripts/test-ci-pipeline-contract.sh:false"

package/scripts/lib/run-benchmark.py

@@ -12,6 +12,9 @@ from pathlib import Path
 
 import yaml
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from atomic_write import atomic_write_text  # noqa: E402
+
 REPO_ROOT = Path(__file__).resolve().parents[2]
 BENCH_DIR = REPO_ROOT / "specs" / "benchmarks"
 REPORTS_DIR = BENCH_DIR / "reports"
@@ -169,8 +172,7 @@ def run_benchmark(skill: str, baseline: bool = False) -> dict:
     REPORTS_DIR.mkdir(parents=True, exist_ok=True)
     yaml_path = REPORTS_DIR / f"BENCHMARK-{skill}-{today}.yaml"
     json_path = REPORTS_DIR / f"benchmark-{skill}.json"
-    with yaml_path.open("w") as f:
-        yaml.dump(
+    yaml_text = yaml.dump(
             {
                 "skill": skill,
                 "run_date": today,
@@ -189,9 +191,9 @@ def run_benchmark(skill: str, baseline: bool = False) -> dict:
             },
             f,
             default_flow_style=False,
-        )
-    with json_path.open("w") as f:
-        json.dump(report, f, separators=(",", ":"))
+    )
+    atomic_write_text(yaml_path, yaml_text)
+    atomic_write_text(json_path, json.dumps(report, separators=(",", ":")))
     print(f"Wrote {yaml_path}")
     print(f"Wrote {json_path}")
     if baseline:

package/scripts/lib/srp_engine_okf.py

@@ -1,7 +1,12 @@
 """OKF concept-page rendering for srp-engine (sync-skills.sh --okf)."""
 # story: e39s04
 # story: BUG-2026-10-30-compliance-akita-masked
+# story: BUG-2026-11-03-atomic-yaml-writes
 import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from atomic_write import atomic_write_text  # noqa: E402
 
 
 def render_okf_concept(skill_data, okf_wiki_skills):
@@ -61,5 +66,4 @@ def render_okf_concept(skill_data, okf_wiki_skills):
         f"> Auto-generated by sync-skills.sh --okf (e39s04) from skills/{name}/SKILL.md"
     ])
     
-    with open(okf_file, 'w', encoding='utf-8') as f:
-        f.write('\n'.join(lines) + '\n')
+    atomic_write_text(okf_file, '\n'.join(lines) + '\n')

package/scripts/lib/trace-stories.py

@@ -15,6 +15,8 @@ import json, os, re, subprocess, sys
 from pathlib import Path
 from datetime import datetime, timezone
 import yaml
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from atomic_write import atomic_write_text  # noqa: E402
 
 ROOT = Path(sys.argv[1])
 MATRIX_JSON = Path(sys.argv[2])
@@ -189,7 +191,7 @@ matrix = {
     }
 }
 MATRIX_JSON.parent.mkdir(parents=True, exist_ok=True)
-MATRIX_JSON.write_text(json.dumps(matrix, indent=2), encoding="utf-8")
+atomic_write_text(MATRIX_JSON, json.dumps(matrix, indent=2), encoding="utf-8")
 
 # --- 6. Emit TRACEABILITY_LATEST.md
 lines = ["# Traceability Matrix", "",
@@ -224,7 +226,7 @@ if stale_tags:
     for st in stale_tags: lines.append(f"- `{st}`")
     lines.append("")
 TRACE_MD.parent.mkdir(parents=True, exist_ok=True)
-TRACE_MD.write_text("\n".join(lines), encoding="utf-8")
+atomic_write_text(TRACE_MD, "\n".join(lines))
 
 # --- 7. Emit OKF bundle (specs/codebase-wiki/)
 OKF_DIR.mkdir(parents=True, exist_ok=True)
@@ -240,7 +242,7 @@ for s in matrix_stories:
     mc = "high" if "high" in confs else ("medium" if "medium" in confs else ("low" if confs else "none"))
     idx_lines.append(f"| [{s['id']}](./{s['id']}.md) | {s['title'][:60]} | {mc} | {s['link_count']} |")
 idx_lines.append("")
-(OKF_DIR / "index.md").write_text("\n".join(idx_lines), encoding="utf-8")
+atomic_write_text(OKF_DIR / "index.md", "\n".join(idx_lines))
 for s in matrix_stories:
     concept = ["---", f"type: Story", f"id: {s['id']}", f"epic: {s['epic_id']}",
         f"bcps: {s['bcp']}", f"wsjf: {s['wsjf']}",
@@ -263,7 +265,7 @@ for s in matrix_stories:
     else:
         concept.append("*No code links found — this is a dark story.*")
     concept.append("")
-    (OKF_DIR / f"{s['id']}.md").write_text("\n".join(concept), encoding="utf-8")
+    atomic_write_text(OKF_DIR / f"{s['id']}.md", "\n".join(concept))
 
 # --- 8. Strict mode
 if STRICT:

package/scripts/lib/trace_renderer.py

@@ -3,6 +3,8 @@
 import json
 from pathlib import Path
 from datetime import datetime, timezone
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from atomic_write import atomic_write_text  # noqa: E402
 
 def emit_matrix_json(matrix_json_path: Path, stories: dict, tagged_sids: set, dark_stories: list, orphan_tags: list, stale_tags: list, matrix_stories: list) -> dict:
     matrix = {
@@ -26,7 +28,7 @@ def emit_matrix_json(matrix_json_path: Path, stories: dict, tagged_sids: set, da
         }
     }
     matrix_json_path.parent.mkdir(parents=True, exist_ok=True)
-    matrix_json_path.write_text(json.dumps(matrix, indent=2), encoding="utf-8")
+    atomic_write_text(matrix_json_path, json.dumps(matrix, indent=2), encoding="utf-8")
     return matrix
 
 def emit_trace_md(trace_md_path: Path, stories: dict, tagged_sids: set, dark_stories: list, orphan_tags: list, stale_tags: list, matrix_stories: list, matrix: dict, dev_status: dict) -> None:
@@ -80,7 +82,7 @@ def emit_trace_md(trace_md_path: Path, stories: dict, tagged_sids: set, dark_sto
         lines.append("")
     
     trace_md_path.parent.mkdir(parents=True, exist_ok=True)
-    trace_md_path.write_text("\n".join(lines), encoding="utf-8")
+    atomic_write_text(trace_md_path, "\n".join(lines))
 
 def emit_okf_bundle(okf_dir: Path, stories: dict, matrix_stories: list) -> None:
     okf_dir.mkdir(parents=True, exist_ok=True)
@@ -104,7 +106,7 @@ def emit_okf_bundle(okf_dir: Path, stories: dict, matrix_stories: list) -> None:
         max_conf = "high" if "high" in confs else ("medium" if "medium" in confs else ("low" if confs else "none"))
         idx_lines.append(f"| [{s['id']}](./{s['id']}.md) | {s['title'][:60]} | {max_conf} | {s['link_count']} |")
     idx_lines.append("")
-    (okf_dir / "index.md").write_text("\n".join(idx_lines), encoding="utf-8")
+    atomic_write_text(okf_dir / "index.md", "\n".join(idx_lines))
     
     # Generate one concept per story
     for s in matrix_stories:
@@ -144,4 +146,4 @@ def emit_okf_bundle(okf_dir: Path, stories: dict, matrix_stories: list) -> None:
         else:
             concept.append("*No code links found — this is a dark story.*")
         concept.append("")
-        (okf_dir / f"{s['id']}.md").write_text("\n".join(concept), encoding="utf-8")
+        atomic_write_text(okf_dir / f"{s['id']}.md", "\n".join(concept))

package/scripts/okf-add-references.py

@@ -8,6 +8,9 @@ import re
 import sys
 from pathlib import Path
 
+sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
+from atomic_write import atomic_write_text  # noqa: E402
+
 
 def main() -> int:
     graph_json = Path(sys.argv[1])
@@ -69,7 +72,7 @@ def main() -> int:
                 content,
             )
         count_updated += 1
-        path.write_text(content, encoding="utf-8")
+        atomic_write_text(path, content)
 
     print(f"  concepts with cross-references: {count_updated}", file=sys.stderr)
     return 0

package/scripts/omp-smoke.ts

@@ -10,7 +10,9 @@
 // fails here exactly as it does in real pi, instead of silently passing.
 // See pi 0.85.1 src/core/extensions/loader.ts (createExtensionRuntime).
 
-import { readFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import bigpowers from "../extensions/omp-hooks.ts";
 
 type AnyObj = Record<string, unknown>;
@@ -118,3 +120,27 @@ console.log(JSON.stringify({
   sendCalls,
   runDetails: runResult.details,
 }));
+
+// Silent-probe check (BUG-2026-11-03-omp-hooks-stderr-leak, issue #189).
+// The tool_call handler resolves the branch of the directory the command will
+// run in. When that directory is not a repository, a git probe that inherits
+// fd 2 paints "fatal: not a git repository" over the TUI. The handler must be
+// invisible: validate-omp-extension.sh runs this mode with stderr captured and
+// fails on any leaked git noise.
+if (process.env.OMP_SMOKE_SILENT_TOOL_CALL === "1") {
+  const toolCall = events.get("tool_call");
+  if (typeof toolCall !== "function") throw new Error("tool_call handler not registered");
+  const nonRepo = mkdtempSync(join(tmpdir(), "omp-nonrepo-"));
+  try {
+    const verdict = await toolCall({
+      toolName: "bash",
+      input: { command: `cd ${nonRepo} && ls` },
+    });
+    // Fail-closed contract: a harmless command in a non-repo dir is not blocked.
+    if (verdict && (verdict as { block?: boolean }).block) {
+      throw new Error(`harmless command in a non-repo dir was blocked: ${JSON.stringify(verdict)}`);
+    }
+  } finally {
+    rmSync(nonRepo, { recursive: true, force: true });
+  }
+}

package/scripts/sync-bugs-registry.sh

@@ -12,6 +12,9 @@ import re
 import sys
 from pathlib import Path
 
+sys.path.insert(0, str(Path(sys.argv[2]) / "scripts" / "lib"))
+from atomic_write import atomic_write_text
+
 bugs_dir = Path(sys.argv[1])
 repo_root = Path(sys.argv[2])
 
@@ -61,7 +64,7 @@ for e in entries:
             val = e[opt].replace('"', "'")
             lines.append(f'    {opt}: "{val}"')
 lines.append("")
-out.write_text("\n".join(lines), encoding="utf-8")
+atomic_write_text(out, "\n".join(lines))
 print(f"sync-bugs-registry: {len(entries)} bugs -> {out}")
 
 # ---- Phase 2: Emit OKF concept bundles (e45s03) ----
@@ -96,7 +99,7 @@ references:
 
 See `specs/bugs/{bug_id}.md` for full investigation and fix details.
 """
-    bundle_path.write_text(bundle, encoding="utf-8")
+    atomic_write_text(bundle_path, bundle)
     okf_count += 1
 
 print(f"sync-bugs-registry: {okf_count} OKF concept bundles -> {bugs_dir}/")

package/scripts/test-atomic-writes.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# story: BUG-2026-11-03-atomic-yaml-writes
+# test-atomic-writes.sh — regression guard for in-place YAML/JSON truncation (#181).
+#
+# `path.write_text(...)` truncates the destination, then streams the new bytes.
+# A reader in that window sees a half file and dies with a YAML ScannerError.
+# The fix writes a same-directory temp file, fsyncs it, and os.replace()s it.
+#
+#   (a) anti-vacuity: the truncating shape IS observable by a concurrent reader
+#   (b) atomic_write_text is never observable half-written
+#   (c) static guard: the runtime state writers use the helper, not bare writes
+#
+# Usage: bash scripts/test-atomic-writes.sh
+
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"
+resolve_repo_root
+cd "$REPO_ROOT"
+source scripts/lib/python-env.sh
+source scripts/lib/test-assertions.sh
+resolve_python
+TA_PASS=0
+TA_FAIL=0
+
+echo "=== test-atomic-writes.sh ==="
+
+# ── (a)+(b) race harness ────────────────────────────────────────────────────
+# One PROCESS writes a large YAML document N times while this process parses the
+# file in a tight loop and counts parse errors. Two processes, not two threads:
+# the GIL makes a thread-based control flaky, and a flaky anti-vacuity check is
+# worse than none. Plain write_text must be caught (otherwise the harness is
+# blind); atomic_write_text must never be caught.
+RACE=$($PYTHON - <<'PY'
+import os, subprocess, sys, tempfile
+from pathlib import Path
+
+KEYS = 400_000
+PAYLOAD = "".join(f"key_{i}: {'x' * 40}\n" for i in range(KEYS))  # ~19 MB
+EXPECTED = len(PAYLOAD.encode())
+ITERATIONS = 8
+ATTEMPTS = 3
+
+PRODUCER = """
+import sys
+from pathlib import Path
+sys.path.insert(0, "scripts/lib")
+from atomic_write import atomic_write_text
+
+mode, target, keys, iterations = sys.argv[1], Path(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4])
+payload = "".join(f"key_{i}: {'x' * 40}\\n" for i in range(keys))
+for _ in range(iterations):
+    if mode == "plain":
+        target.write_text(payload, encoding="utf-8")
+    else:
+        atomic_write_text(target, payload)
+"""
+
+def run(mode):
+    """Count samples where a reader saw a size that is neither empty nor final.
+
+    Sampling the size instead of parsing it is what makes the control reliable:
+    a 19 MB write keeps the truncate window open for milliseconds, so a poller
+    always lands inside it, while os.replace() swaps the inode and never shows
+    an intermediate size at all.
+    """
+    partial = 0
+    for _attempt in range(ATTEMPTS):
+        target = Path(tempfile.mkdtemp(prefix="atomic-race-")) / "state.yaml"
+        target.write_text(PAYLOAD, encoding="utf-8")
+        proc = subprocess.Popen([sys.executable, "-c", PRODUCER, mode, str(target), str(KEYS), str(ITERATIONS)])
+        seen = 0
+        while proc.poll() is None:
+            try:
+                size = os.path.getsize(target)
+            except FileNotFoundError:
+                size = -1
+            if size not in (EXPECTED, -1):
+                seen += 1
+        proc.wait()
+        partial += seen
+        if partial:
+            break
+    return partial
+
+print(f"{run('plain')} {run('atomic')}")
+PY
+)
+
+TRUNCATING_PARTIALS=$(echo "$RACE" | awk '{print $1}')
+ATOMIC_PARTIALS=$(echo "$RACE" | awk '{print $2}')
+
+[[ "${TRUNCATING_PARTIALS:-0}" -gt 0 ]] \
+  && ta_pass "(a) plain write_text exposes a partial file ($TRUNCATING_PARTIALS samples)" \
+  || ta_fail "(a) plain write_text was never caught — the harness cannot see the race"
+
+[[ "${ATOMIC_PARTIALS:-1}" -eq 0 ]] \
+  && ta_pass "(b) atomic_write_text: 0 partial samples" \
+  || ta_fail "(b) atomic_write_text exposed $ATOMIC_PARTIALS partial samples"
+
+# ── (c) static guard: runtime state writers go through the helper ───────────
+# Fixtures, one-off migration patchers and test harnesses may write freely; the
+# files that hold live spec state may not.
+WATCHED=(
+  "scripts/yaml-tools.py"
+  "scripts/sync-bugs-registry.sh"
+  "scripts/lib/trace-stories.py"
+  "scripts/lib/trace_renderer.py"
+  "scripts/lib/blind-spots.py"
+  "scripts/lib/blind-spot-checks.py"
+  "scripts/lib/ab_report.py"
+  "scripts/lib/run-benchmark.py"
+  "scripts/okf-add-references.py"
+  "scripts/lib/srp_engine_okf.py"
+)
+HITS=""
+for f in "${WATCHED[@]}"; do
+  [ -f "$f" ] || continue
+  # bare truncating writes: .write_text(...) or open(..., "w"), minus tmp targets
+  found=$(grep -nE '\.write_text\(|\.open\(["'"'"']w["'"'"']|open\([^)]*["'"'"']w["'"'"']' "$f" \
+    | grep -vE 'atomic_write|\.tmp|tmp_name' || true)
+  [ -n "$found" ] && HITS+="$f:"$'\n'"$found"$'\n'
+done
+
+[[ -z "$HITS" ]] \
+  && ta_pass "(c) all ${#WATCHED[@]} watched state writers use atomic_write" \
+  || ta_fail "(c) truncating writes still in state writers:"$'\n'"$HITS"
+
+echo "$TA_PASS passed, $TA_FAIL failed"
+[[ "$TA_FAIL" -eq 0 ]]

package/scripts/validate-omp-extension.sh

@@ -121,6 +121,28 @@ else
   rm -f "$SMOKE_ERR"
 fi
 
+# ── 7. tool_call is silent outside a repo (BUG-2026-11-03, issue #189) ────────
+# A guard that inspects the command must not paint git's stderr on the agent
+# TTY. The probe runs the REAL tool_call handler with a command that cds into a
+# directory that is not a repository; any leaked "fatal:" lands on this
+# script's captured stderr because execSync inherits fd 2.
+echo "--- [OMP] tool_call stays quiet outside a git repo ---"
+if [[ ! -f "$SMOKE" ]] || ! command -v node >/dev/null 2>&1; then
+  echo "warn: node or $SMOKE unavailable — skipping the silent-probe check"
+else
+  SILENT_ERR=$(mktemp)
+  if OMP_SMOKE_SILENT_TOOL_CALL=1 node "$SMOKE" >/dev/null 2>"$SILENT_ERR"; then
+    if grep -qi 'fatal: not a git repository' "$SILENT_ERR"; then
+      ta_err "tool_call leaked git stderr onto the TUI: $(grep -i -m1 'fatal: not a git repository' "$SILENT_ERR")"
+    else
+      ta_ok "tool_call writes nothing to stderr for a non-repo target"
+    fi
+  else
+    ta_err "silent tool_call probe failed — $(head -3 "$SILENT_ERR" 2>/dev/null | tr '\n' ' ')"
+  fi
+  rm -f "$SILENT_ERR"
+fi
+
 # ── Summary ────────────────────────────────────────────────────────────────
 echo "---"
 if [[ "$ERRORS" -eq 0 ]]; then

package/scripts/yaml-tools.py

@@ -17,6 +17,9 @@ from typing import Any
 
 import yaml
 
+sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
+from atomic_write import atomic_write_text  # noqa: E402
+
 
 def set_path(path: Path, dotted_key: str, value: str) -> None:
     """Surgically set one dotted-path key, preserving everything else in the file."""
@@ -43,12 +46,12 @@ def set_path(path: Path, dotted_key: str, value: str) -> None:
             except ValueError:
                 cur[last] = value.strip('"').strip("'")
 
-    path.parent.mkdir(parents=True, exist_ok=True)
     # sort_keys=False preserves author-intended ordering (e.g. epics[]
     # sequencing by WSJF priority) instead of alphabetizing every key.
-    path.write_text(
+    # atomic_write_text: a reader must never see this file truncated (#181).
+    atomic_write_text(
+        path,
         yaml.safe_dump(data, sort_keys=False, allow_unicode=True, width=100),
-        encoding="utf-8",
     )